From d7de2a8bf4348a0cd96d7e6edc82dfb7a94811ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raimund=20And=C3=A9e?= Date: Sun, 29 Jan 2017 23:46:28 +0100 Subject: [PATCH] cleanup --- .vs/NTFSSecurity/v14/.suo | Bin 214528 -> 85504 bytes .../Debug/AlphaFS.csproj.FileListAbsolute.txt | 10 - .../AlphaFS.csproj.GenerateResource.Cache | Bin 778 -> 0 bytes AlphaFS/obj/Debug/AlphaFS.dll | Bin 312320 -> 0 bytes .../Alphaleonis.Win32.Resources.resources | Bin 4456 -> 0 bytes ...gnTimeResolveAssemblyReferencesInput.cache | Bin 6576 -> 6500 bytes .../Debug/TempPE/Resources.Designer.cs.dll | Bin 9216 -> 0 bytes .../AlphaFS.csproj.FileListAbsolute.txt | 3 - .../AlphaFS.csproj.GenerateResource.Cache | Bin 778 -> 0 bytes ...phaFS.csprojResolveAssemblyReference.cache | Bin 895 -> 0 bytes .../Alphaleonis.Win32.Resources.resources | Bin 4456 -> 0 bytes ...gnTimeResolveAssemblyReferencesInput.cache | Bin 5897 -> 0 bytes .../TempPE/Resources.Designer.cs.dll | Bin 9216 -> 0 bytes AlphaFS/obj/Net35 Debug/build.force | 0 .../AlphaFS.csproj.FileListAbsolute.txt | 10 - .../AlphaFS.csproj.GenerateResource.Cache | Bin 943 -> 0 bytes AlphaFS/obj/Net452 Debug/AlphaFS.dll | Bin 313856 -> 0 bytes AlphaFS/obj/Net452 Debug/AlphaFS.pdb | Bin 947712 -> 0 bytes .../Alphaleonis.Win32.Resources.resources | Bin 4456 -> 0 bytes .../DesignTimeResolveAssemblyReferences.cache | Bin 725 -> 0 bytes ...gnTimeResolveAssemblyReferencesInput.cache | Bin 6309 -> 0 bytes .../TempPE/Resources.Designer.cs.dll | Bin 9216 -> 0 bytes ...le_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs | 0 ...le_5937a670-0e60-4077-877b-f7221da3dda1.cs | 0 ...le_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs | 0 Bin/Debug/Net35/AlphaFS.XML | 21563 ---------------- Bin/Debug/Net35/AlphaFS.dll | Bin 312320 -> 0 bytes .../Net35/AlphaFS.dll.CodeAnalysisLog.xml | 17199 ------------ Bin/Debug/Net35/AlphaFS.dll.config | 3 - .../AlphaFS.dll.lastcodeanalysissucceeded | 0 Bin/Debug/Net35/AlphaFS.pdb | Bin 947712 -> 0 bytes Bin/Debug/Net452/AlphaFS.XML | 21563 ---------------- Bin/Debug/Net452/AlphaFS.dll | Bin 313856 -> 0 bytes .../Net452/AlphaFS.dll.CodeAnalysisLog.xml | 100 - Bin/Debug/Net452/AlphaFS.dll.config | 3 - .../AlphaFS.dll.lastcodeanalysissucceeded | 0 Bin/Debug/Net452/AlphaFS.pdb | Bin 947712 -> 0 bytes NTFSSecurity/NTFSSecurity.csproj.user | 6 + .../Properties.Resources.Designer.cs.dll | Bin 0 -> 3584 bytes Security2/bin/Debug/AlphaFS.pdb | Bin 947712 -> 0 bytes TestClient/bin/Debug/AlphaFS.pdb | Bin 947712 -> 0 bytes 41 files changed, 6 insertions(+), 60454 deletions(-) delete mode 100644 AlphaFS/obj/Debug/AlphaFS.csproj.FileListAbsolute.txt delete mode 100644 AlphaFS/obj/Debug/AlphaFS.csproj.GenerateResource.Cache delete mode 100644 AlphaFS/obj/Debug/AlphaFS.dll delete mode 100644 AlphaFS/obj/Debug/Alphaleonis.Win32.Resources.resources delete mode 100644 AlphaFS/obj/Debug/TempPE/Resources.Designer.cs.dll delete mode 100644 AlphaFS/obj/Net35 Debug/AlphaFS.csproj.FileListAbsolute.txt delete mode 100644 AlphaFS/obj/Net35 Debug/AlphaFS.csproj.GenerateResource.Cache delete mode 100644 AlphaFS/obj/Net35 Debug/AlphaFS.csprojResolveAssemblyReference.cache delete mode 100644 AlphaFS/obj/Net35 Debug/Alphaleonis.Win32.Resources.resources delete mode 100644 AlphaFS/obj/Net35 Debug/DesignTimeResolveAssemblyReferencesInput.cache delete mode 100644 AlphaFS/obj/Net35 Debug/TempPE/Resources.Designer.cs.dll delete mode 100644 AlphaFS/obj/Net35 Debug/build.force delete mode 100644 AlphaFS/obj/Net452 Debug/AlphaFS.csproj.FileListAbsolute.txt delete mode 100644 AlphaFS/obj/Net452 Debug/AlphaFS.csproj.GenerateResource.Cache delete mode 100644 AlphaFS/obj/Net452 Debug/AlphaFS.dll delete mode 100644 AlphaFS/obj/Net452 Debug/AlphaFS.pdb delete mode 100644 AlphaFS/obj/Net452 Debug/Alphaleonis.Win32.Resources.resources delete mode 100644 AlphaFS/obj/Net452 Debug/DesignTimeResolveAssemblyReferences.cache delete mode 100644 AlphaFS/obj/Net452 Debug/DesignTimeResolveAssemblyReferencesInput.cache delete mode 100644 AlphaFS/obj/Net452 Debug/TempPE/Resources.Designer.cs.dll delete mode 100644 AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs delete mode 100644 AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs delete mode 100644 AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs delete mode 100644 Bin/Debug/Net35/AlphaFS.XML delete mode 100644 Bin/Debug/Net35/AlphaFS.dll delete mode 100644 Bin/Debug/Net35/AlphaFS.dll.CodeAnalysisLog.xml delete mode 100644 Bin/Debug/Net35/AlphaFS.dll.config delete mode 100644 Bin/Debug/Net35/AlphaFS.dll.lastcodeanalysissucceeded delete mode 100644 Bin/Debug/Net35/AlphaFS.pdb delete mode 100644 Bin/Debug/Net452/AlphaFS.XML delete mode 100644 Bin/Debug/Net452/AlphaFS.dll delete mode 100644 Bin/Debug/Net452/AlphaFS.dll.CodeAnalysisLog.xml delete mode 100644 Bin/Debug/Net452/AlphaFS.dll.config delete mode 100644 Bin/Debug/Net452/AlphaFS.dll.lastcodeanalysissucceeded delete mode 100644 Bin/Debug/Net452/AlphaFS.pdb create mode 100644 NTFSSecurity/NTFSSecurity.csproj.user create mode 100644 NTFSSecurity/obj/Debug/TempPE/Properties.Resources.Designer.cs.dll delete mode 100644 Security2/bin/Debug/AlphaFS.pdb delete mode 100644 TestClient/bin/Debug/AlphaFS.pdb diff --git a/.vs/NTFSSecurity/v14/.suo b/.vs/NTFSSecurity/v14/.suo index 9cc1e78f78a10dc4050ac7185b57ba739009ae6d..a4599212791c2011e46403e95e113683f5bb62be 100644 GIT binary patch delta 6598 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 J#kbnR{{_A8ZL|OY literal 214528 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 diff --git a/AlphaFS/obj/Debug/AlphaFS.csproj.FileListAbsolute.txt b/AlphaFS/obj/Debug/AlphaFS.csproj.FileListAbsolute.txt deleted file mode 100644 index e5e41ff..0000000 --- a/AlphaFS/obj/Debug/AlphaFS.csproj.FileListAbsolute.txt +++ /dev/null @@ -1,10 +0,0 @@ -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.dll.config -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.XML -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.dll -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.pdb -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.dll.CodeAnalysisLog.xml -C:\Users\Administrator\Desktop\NTFSSecurity\Bin\Debug\Net35\AlphaFS.dll.lastcodeanalysissucceeded -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Debug\Alphaleonis.Win32.Resources.resources -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Debug\AlphaFS.csproj.GenerateResource.Cache -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Debug\AlphaFS.dll -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Debug\AlphaFS.pdb diff --git a/AlphaFS/obj/Debug/AlphaFS.csproj.GenerateResource.Cache b/AlphaFS/obj/Debug/AlphaFS.csproj.GenerateResource.Cache deleted file mode 100644 index 17f34c8f7c640ee14973483d6841d9b5dab70a67..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 778 zcma)3OG*Pl5S^Gz%ts|IBnw>xaUmF*gb;KS1S5V>!5`wrMQ6GOn{=i_*Nh~30WaVw zJdPg2J7`rn0{n9CRW`Vkb?#cAE5z4vt`aY5Nd$dW}}t4mZPQQ?(niC4KI- zp5Edda37*w7(%2V3N#?=DLTOGJ#7H1J&ACvqdq9U?`j7@Y~47QSxqOLrkc=YiL>N0 z{^J#^ol`#)Wmhi77{fqxtufS|mVx3x;%zK@1||)1^d`sfXXz{zl#Z=bdy+P)n7@)H0rb3V*7N;xA+6Wp7uQ;f=EGn7Z)aQE zJa4H~CM^04d4dZ6aU#!}7sw@>xByU)F{27saI#n+@EMxvX8d+{gF+K$d0A!iZ7f#5 zjT^Jk8zDg?2e3R9HxlC$t8}PAEluTMq%p=kNt@41Y$>uxp1^y4dU$<%dCV+wh)?+g DNWA8G diff --git a/AlphaFS/obj/Debug/AlphaFS.dll b/AlphaFS/obj/Debug/AlphaFS.dll deleted file mode 100644 index ec222ca91d42a63209ec0f2b8852a4020d4a84c9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 312320 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

b}QC#9^3)AZ*S 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
2F#_$7G*x6+c`7=B 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 (chIeEYYQFS*6|0uT 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%0D(cmDJQDtTkw>_)tXxQ7ejA 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 U>-|WmEm@9XcNhD zAD~kNjwT->sb+F24Ai4KIw}+;(H(p~v1l zKQZ`D@0vpc|GhPSE&A@4-~8;C&TRP1?b5fOF9esTUkeYOEY$z?lXn}f{7`f1Z|{Bm zmpivV{rFek_{QkHjJ=M;e(yfU{(BeE@ns2e}{MI)&?#*egND zMaX>%>k9C{hpdnFZD8KV-t~2i<&LlfhZQE6VI@{zn#H(IG9T+Ic1!FiQ`k+gsyVZ{ zJPwuHBxoK$ft}caN11f%0Ben3Ep`Ax!;3{m0VTL$b-8Z0D~yf;SL}Te0c^-Yy>LOER%~= zl5?p8-_JnuD5!TILjV5@#0& zl?|9FI2JiJokU(FoToYzofpLI>ri=c8VaaHDTmW}nDq%2t$Pq2aSD#2muPIX*gA~c zK8lM5OWMEzyrE-i_tf5a`Q@8^$yP|PJx0Gf+DAxk~Uc2b|?U1sfDsa5kCo-PR#D&(_o^hvpm5> zIt$e_=V(l)%^hNoZeV+7;e2{~p*zS*6ECeGbwPUqnt^mj%^+Q%Ia#$26JI}#$^z9UJcA`F+7D;@L5H&wxf z(n+<(E86h5Cb$u26M+Zakn4spevHT1oVO|OE0PF|@MFP4X+#if)5>|h?UPW%!qlY_ zJg*xq4rRx6Q*b{>6&xOgPN|$aUQWIEgf7g&xllA^ATs~qOb8dwOej2elSfgD%X%Xc zb)hJLN}`;3?#Fm=Z@_+)$C_7#qQDUOxj{yXEd=pEG)n?hV zNu!|+@|5$oPDGKY`VkKxjgsN*rLCAt1<|;c^Y)CWERU2#D`M^|96MLj(2-^%%Ly`D z@sTAczJH>9Ze#dY=gO~(oVPyPEhc4B?)79FcsEiu?U}3*bKZk_jdvd&q%Bw$T*22^ zHlb-pcU$R7g}hn`w|P>iYFu0K?BPir%=2h`~296iP4-lJdNBD!sq9O(Yx9q zz!~ZT^kJY?>`PQ!D==fBCQ%vN@B<|7;b|kAs1f*2HR(zW5e1}rfJjALf=tc5-@-{B zB}FJOSr>6lhptAL1(rH8)C-o+q0fD?U6a+CFgb5`R$429#K^b>4%@)U2F3@(@lvda zRE~e?`?a^f=-#h+yPjZ6Rvn$hR))gOsWO@(L}(Sa@{RFZ-VmiZrl}TpkER&<7Or&SFt5q|a`{g#FwyboDeAXo<5t8^&mX+>?*X6Hah9ULc z!Zaj_5Y+9Pmmb`m)r*CQ$XZqK{|nGIToCbsHuKzq+vqUr8C%my6!N+s2Q`;I41X+! z`RUVEn5HnN9T@iuKbTJ%d<=mXQwE<<5z%E@TQ^O3J+ZM%>mpu0P6@5T>2!L0!P4yo N7P5Z6JA2yc{2v0xs(t_f diff --git a/AlphaFS/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/AlphaFS/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache index d51f1181e7d2f131927e89ce93deeaefa3cc2ba2..1023ea38e9482bb6a497bdbbb8508b90829b3051 100644 GIT binary patch delta 158 zcmdmB{KRO(3T}lAXRDad;?$zzn4-kIl%g1y{N&Qy)Vz}7828K)kJ6;gx4GFE73>M9 bnk>Srs^CIE(dHapD^3MlLaJ_xU1tISeCj)t delta 241 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 diff --git a/AlphaFS/obj/Net35 Debug/AlphaFS.csproj.FileListAbsolute.txt b/AlphaFS/obj/Net35 Debug/AlphaFS.csproj.FileListAbsolute.txt deleted file mode 100644 index 6875414..0000000 --- a/AlphaFS/obj/Net35 Debug/AlphaFS.csproj.FileListAbsolute.txt +++ /dev/null @@ -1,3 +0,0 @@ -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Net35 Debug\AlphaFS.csprojResolveAssemblyReference.cache -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Net35 Debug\Alphaleonis.Win32.Resources.resources -C:\Users\Administrator\Desktop\NTFSSecurity\AlphaFS\obj\Net35 Debug\AlphaFS.csproj.GenerateResource.Cache diff --git a/AlphaFS/obj/Net35 Debug/AlphaFS.csproj.GenerateResource.Cache b/AlphaFS/obj/Net35 Debug/AlphaFS.csproj.GenerateResource.Cache deleted file mode 100644 index 17f34c8f7c640ee14973483d6841d9b5dab70a67..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 778 zcma)3OG*Pl5S^Gz%ts|IBnw>xaUmF*gb;KS1S5V>!5`wrMQ6GOn{=i_*Nh~30WaVw zJdPg2J7`rn0{n9CRW`Vkb?#cAE5z4vt`aY5Nd$dW}}t4mZPQQ?(niC4KI- zp5Edda37*w7(%2V3N#?=DLTOGJ#7H1J&ACvqdq9U?`j7@Y~47QSxqOLrkc=YiL>N0 z{^J#^ol`#)Wmhi77{fqxtufS|mVx3x;%zK@1||)1^d`sfXXz{zl#Z=bdy+P)n7@)H0rb3V*7N;xA+6Wp7uQ;f=EGn7Z)aQE zJa4H~CM^04d4dZ6aU#!}7sw@>xByU)F{27saI#n+@EMxvX8d+{gF+K$d0A!iZ7f#5 zjT^Jk8zDg?2e3R9HxlC$t8}PAEluTMq%p=kNt@41Y$>uxp1^y4dU$<%dCV+wh)?+g DNWA8G diff --git a/AlphaFS/obj/Net35 Debug/AlphaFS.csprojResolveAssemblyReference.cache b/AlphaFS/obj/Net35 Debug/AlphaFS.csprojResolveAssemblyReference.cache deleted file mode 100644 index 6787c9addf8efe880abe7da04fece877b3642a27..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 895 zcmb7C!D`z;5M9fbV##vwwUC1gy~PMSsc{IHLPbnMn~-9YUQA)79nr-rZP;BUxc?Ez zKlF3@1Eus>=)ISA$FXopO(83I+LhkSyf-_fMhN+B7rt?Yj)f2BJXKQ5%tWtCE?6|9 zdZD9OD(H2uKxr4J>DJ0mV4!A7;aBlnn-K z*r$io#bVF5*O)G~fqZJH0c80Z7qB|j_a1&(6+%F2tOOmMQvK1;L;$Mx>lPXa|E2C& zLhx2nHleAJYG>`I8O!{dDo`Cv8cPP3O5Sh=s)-+_{1Y^+Bkf&LQGzC$?^@xI;glXW=A1p1lec=l>D|T2Y(7ymhg+!@ z^P2;EBg6jaU^HJ>o+(;rYjo8vCWMD2j-Qq)*Qr#3ClSUsZT!*G;@47abO&vrBi}~| z5Ly;oJnnB?{XKOL(W@EQpH$O;4G9I+=3FwKabO|U8uCOeFKjPD2G>w9C{hkO)G0Lv z6vpaZRThTlu)g$mR<#bph~qdlr;W2j_Ilr+eg1M91c4XYW3cILP+Q4H(%t>niqw8g SLR;vH{QUK;BJDmRwf+FQT?3Z@ diff --git a/AlphaFS/obj/Net35 Debug/Alphaleonis.Win32.Resources.resources b/AlphaFS/obj/Net35 Debug/Alphaleonis.Win32.Resources.resources deleted file mode 100644 index 1678384181ca0c50fe7eae41276c73944b02f26d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4456 zcmb7IUyM{&89%qSpd^MwiluZzPl3f&mg%yv3v3{=%(Cp-Wp=Z(ED3_sJNKTMIqscv zhI8(nWvGo}8k;6WEm@9XcNhD zAD~kNjwT->sb+F24Ai4KIw}+;(H(p~v1l zKQZ`D@0vpc|GhPSE&A@4-~8;C&TRP1?b5fOF9esTUkeYOEY$z?lXn}f{7`f1Z|{Bm zmpivV{rFek_{QkHjJ=M;e(yfU{(BeE@ns2e}{MI)&?#*egND zMaX>%>k9C{hpdnFZD8KV-t~2i<&LlfhZQE6VI@{zn#H(IG9T+Ic1!FiQ`k+gsyVZ{ zJPwuHBxoK$ft}caN11f%0Ben3Ep`Ax!;3{m0VTL$b-8Z0D~yf;SL}Te0c^-Yy>LOER%~= zl5?p8-_JnuD5!TILjV5@#0& zl?|9FI2JiJokU(FoToYzofpLI>ri=c8VaaHDTmW}nDq%2t$Pq2aSD#2muPIX*gA~c zK8lM5OWMEzyrE-i_tf5a`Q@8^$yP|PJx0Gf+DAxk~Uc2b|?U1sfDsa5kCo-PR#D&(_o^hvpm5> zIt$e_=V(l)%^hNoZeV+7;e2{~p*zS*6ECeGbwPUqnt^mj%^+Q%Ia#$26JI}#$^z9UJcA`F+7D;@L5H&wxf z(n+<(E86h5Cb$u26M+Zakn4spevHT1oVO|OE0PF|@MFP4X+#if)5>|h?UPW%!qlY_ zJg*xq4rRx6Q*b{>6&xOgPN|$aUQWIEgf7g&xllA^ATs~qOb8dwOej2elSfgD%X%Xc zb)hJLN}`;3?#Fm=Z@_+)$C_7#qQDUOxj{yXEd=pEG)n?hV zNu!|+@|5$oPDGKY`VkKxjgsN*rLCAt1<|;c^Y)CWERU2#D`M^|96MLj(2-^%%Ly`D z@sTAczJH>9Ze#dY=gO~(oVPyPEhc4B?)79FcsEiu?U}3*bKZk_jdvd&q%Bw$T*22^ zHlb-pcU$R7g}hn`w|P>iYFu0K?BPir%=2h`~296iP4-lJdNBD!sq9O(Yx9q zz!~ZT^kJY?>`PQ!D==fBCQ%vN@B<|7;b|kAs1f*2HR(zW5e1}rfJjALf=tc5-@-{B zB}FJOSr>6lhptAL1(rH8)C-o+q0fD?U6a+CFgb5`R$429#K^b>4%@)U2F3@(@lvda zRE~e?`?a^f=-#h+yPjZ6Rvn$hR))gOsWO@(L}(Sa@{RFZ-VmiZrl}TpkER&<7Or&SFt5q|a`{g#FwyboDeAXo<5t8^&mX+>?*X6Hah9ULc z!Zaj_5Y+9Pmmb`m)r*CQ$XZqK{|nGIToCbsHuKzq+vqUr8C%my6!N+s2Q`;I41X+! z`RUVEn5HnN9T@iuKbTJ%d<=mXQwE<<5z%E@TQ^O3J+ZM%>mpu0P6@5T>2!L0!P4yo N7P5Z6JA2yc{2v0xs(t_f diff --git a/AlphaFS/obj/Net35 Debug/DesignTimeResolveAssemblyReferencesInput.cache b/AlphaFS/obj/Net35 Debug/DesignTimeResolveAssemblyReferencesInput.cache deleted file mode 100644 index 6fef21ed50893fdb86a16524419ad4dcb3883cdb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5897 zcmeHLZBH9V5VpZwFoYD-ln`iAw@qJEStnlNLQts$Hcn9+glw05;1F5gjm?I;U2As_ z<05`be?irs*v_2a2q7dOBk{q9JYHsZo}HbWT|Yaqcq|tC4dD<7C?BjmnE^KA(OO4eU1R#x_VFxt~K-# zzZ~Mpd;0TMX&=|A%>_5}T!Cw(;-Dw%o?)s4Ou2_U%pB^;+6BdUUCAm&h*mYFpvJXP z&7MIL7iNG$IEz5%gK=(_=?h)2q~J%OzP?&pb@ZMa zToa~T+XTE~C=3svZE_K*6(v0rYA8Y#6bOVWC>bE=TSR)GI@%~K){r%9S+UqK%At5X zZs7-IZ0PTiQd1iUFg@}8x`qpseuHGyK|wAf}&t0g4T4W_{9l3mB%-Yj=HWafAg33P{mw#nw^$(i*4ae~~c^QT7k z>8yJJ7sSOF5;-Ri`pC$-vt2HfO5lcyo2Ikw*AH2t_#+@O^UCN@4%hJN@ZMKZW{4)cTxSf#$yT5L;uU zv$ONdi_6I`@c-CYiXuxNYnp`J;3Dv>N7zo-p6^>TQ43BWMZu@oTg3Q(y-6_eE?~RS zWx$$6jNDBy>dZZ2HP9WPIRsiopx0b@vY~r#mZIWx->lPHxYOZv(fYnb`<3h2w;3fx z=LuSG-pIPFn9!`vSrIBhp&cB?gTuJ5*N%R3ndqQ6!0TS1M-DXq3q}u)TlEL*`8P4R zYkj2h^1*B2ZRCBwUw)sN=idJ4X!0qZdYvalKk8JAvc5uLU+-8=5gCY#)7VH9us{?i zVi2)~^RvW>DZHmm5p|#^Mf8CjvA#hubDF!fVs&PHi@j5)zj0xxMnT1kE!-7n)-%-4 zo|Z2!$28BZ@36lgjO2U7nK&)7291SLbN2JC{BtvM-;;! jv2ooO5b+7LyB9^9VCWhCXK*TftR6c!6}ok@{qg?+$hVPj diff --git a/AlphaFS/obj/Net35 Debug/TempPE/Resources.Designer.cs.dll b/AlphaFS/obj/Net35 Debug/TempPE/Resources.Designer.cs.dll deleted file mode 100644 index 74f00d6448fd926bd4069166f10781e6aaedee12..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9216 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 Z*Y~$ diff --git a/AlphaFS/obj/Net452 Debug/AlphaFS.dll b/AlphaFS/obj/Net452 Debug/AlphaFS.dll deleted file mode 100644 index f054ca64c66e077fd320bfa151cdf3d286ea95d9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 313856 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

SVBz@*GeL0q>yExZtqQa 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 H!g_-VWvffYUVTC%=G;H>pJ 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�j-G`@ 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%0AWJ;L4Np6G=+6S3==T6e`IS@M-HfbKq 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 Se!uE{e;X?EcXfEH9QZ%yWu3|Z diff --git a/AlphaFS/obj/Net452 Debug/AlphaFS.pdb b/AlphaFS/obj/Net452 Debug/AlphaFS.pdb deleted file mode 100644 index 6069f9f57e6cdf722e130055abeb41d3175ec18d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 947712 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 R^>$cuwh(LXfQw{HP7JtUofMq~3vR>kq* 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 (V|0RFvi~6*cOa$S%ndp2i}*Du!LKhV$6}=T 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 diff --git a/AlphaFS/obj/Net452 Debug/Alphaleonis.Win32.Resources.resources b/AlphaFS/obj/Net452 Debug/Alphaleonis.Win32.Resources.resources deleted file mode 100644 index 7dd13bb098790f3682663036a8d6ffadbeace856..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4456 zcmb7IUyM{&89!57P!dBT#ZtPVr@&$>%k8r4F0g^fGRv}Sm)*_IvLpyj@7#N4=D2sx z8P2(PmZ3I^X>6Jhl?Ro^q(PISzBKw$9<=R?X_L00p~fcagH2;-8XMXsVAS~F?>l!c zGy5;K48xss&hPvG{l0rI*IxhVfv+3SgF;)ey^84Jv^U8abm<7 zdF{r{-H*TdN%xQK?eF$I{mz)tMIBTTw=fVIZ2Cfg68p~WI2fD+uW8sN$a<^it*USw0)FS27;H*ivb z_$Ucjh!B`8NgOJGKAZFBpo){K1{4I&Y8LMdRz3@1|Mz6?2s`Tl^$uI3a7)ACB3w#v zN(wAKWvn9Sb{#vW!@qZ+s%sRsB4=wH;36BtI>bjHfB_WgP#cg2zC43PHVhSMmdQmb z$yunOj97LOO86MeDroJrl*dW~Ah1tuvUMfUIK&zdj+|SU0NeNJup&DFxI%;W!4=~Y zW7uyX?2)j6!3hVLcOhp5GdT=U3@ehAV3U*_fWVHW0tE-6%2Qb<-BqwNfNoh1O`xmZGXFFn zgG(W^Fi2If_?JA-nv{C$4BSXt_!30BCR^bWh?<;&CWQ8(h1&(L9v3qPLqRx^ihF{7L@WVn+5z5&?uehlr-() z&p>QP))&JNrX*2zjcZscw05E~YXZtUp>u$x?OJ37duK=3NnuD5!TIM8l5@#0& zl?|9FI2JiJoj_hBoToYzoEOCHYfyP$8VaaHDTmW}nDq%2t#c3_b_$N5muPG>**c8d z9*Tzq8@34uddx1?i~!brImLUh4}H3x5q`aaImkwG(srZXv_ zo6i_2iIEzE7>Q@8^)}BbPJx0Gf+DAxk~Uc2b|?U1sfDu10)7%OotT})r@=&1XL*8& zbQY><&e51on>)lF-N5>1;e2{~p*zS*6ECeGbw90qsUbja>PUp`J0|RaY;{U(M~@f^hF~ zN3?9d5V5H<+VgSgH0s6UjYmQj`r9KT?c=rwqpnV=9SM=#-or_`EDV>HD;@L5Hxp1!qlV^ zJg@6b4rRx5LvTMx6&xCYPN|$aUP`_Aj4sT=xllA@ATs~qOb8cFk1ITPlSfgL%UV4W zHK8bga-y7h?#Fm=ufu+Y$C_7!qQDUO*+5`dD_%Cb#%&Vdsos{8s3Y`sxou?F)$Q>c_JL%zmIb5&mNr6!90&v2W*~NT`}qoGPR-$wMdE8N-dHk=1~(b zw`=A0Xz|cTtf-F_yso8+z1;R;Q%R_avs(E)P4k?Nu+NVkA0P2@L(|9|A$)#L7`>|% z0-T{fKpzHL#lA$vwE{C1suGp4bw5Dj9-KC^ff|ATRFjUx5K%y?`-oJ;CCF6W`z@UG zQBs5glQj`nb?9n@SzxInL%m@69QxcR+f`Yq3ghK=XQj0wNQ{h|;IIvhtYdsY952O+ zNagsKzF+6|72NwZZ`BiQ$*QB1*ve42IaNYagb1zdR=zQQGdDDnwqm3ZYLNIZa6St)H{AXNw=s!p(J&}zIyNN#-DtUB>zI~(N- z@prP&ADA#mTCjN z_zaAdx*GR~ETN|tr?qmmfpG=3GhFrJ(|Vy~{ti}iy@YDKNCw5IcwY4TVwCU!4=CBg z?Kx&E>!6%D?tr{Hg;cP%8V_!ckU}ZQ9U@pZ<@Unyg#x1PG*Fr(|8?C(hw#1TV#0H$ z&F-e2cB;!uZoqUYXsQLA8hs@Nm^OWw$*<7FifrqQs~W85H5y(J?6tS$I=YSZXbbbv zKk3{f4J6WnX!|%^WWChkd4^WYyu`{Q_E<+av%0 diff --git a/AlphaFS/obj/Net452 Debug/DesignTimeResolveAssemblyReferencesInput.cache b/AlphaFS/obj/Net452 Debug/DesignTimeResolveAssemblyReferencesInput.cache deleted file mode 100644 index 4b2c8eb9ad6b25e78e2e77eb247310a454544ee1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6309 zcmeHLZBH9V5VpZwFoYCSN(dzBMNQizvQ9SO0FkIfY@Awc5V9TmfwRc^ZfrK(i?zE4 zxQO4`;8&i5%Xt4uUOMcpbvU4q(1CGt6MdcJ@HG#I*~(6PpPg9v%m#d$`>5ubjwyuRDcQVV27y#Io-U%m~08ZfgYk+%?N06 zsYLs{LlP&ZfLyqMiY_|if|a=|P49h=AA)#xGrPcL%VBLYc(r3U&=xx#cZ6?&l)l)+ z(Q}1!!jS8B0lOS{io4M5a#d5uOL9JtP=*Ew@K9Az_%15_gqj|R9yfH0HlmGcS}Zn- zbR-^+YxqSP8~JOj(v}Kb3{PBNOHsfX@4y4WE#r4|*2nDL-Yp`yBX*e+zz*Z$<5DDA zQG$ETwC+mF7Y?tV@3Al6VymkxXXRdJ*Oylyv$kGK-!_grI@Cef zk_qiT(wH`dq;Oj9BBwVM1k%S$fEj^Z)7ajsMi?@Ev|{9prF0L1cH!pM$(i;5HF^0r z<_C%R)7-RO?hzVe2<6NI$V26~%j_tKN1Mgk1adRRa%MTZp8O8~$0kzbV)|-xM2utZxwiHY>j}el9Bn?V!3m^j70CY@ zLH}RA#wYkFFs$%Zpe>+|{MYDcG3$^uLG~0aq9TTh5JNWcDWQii3;o5(+Uu8Q%h6zVJZJWBVCaU&XvQ9hnFy!~2rWH9OZ$VgM63D~jW~leQWeaTtc%Uj zVuH5s@X{GxI(>a!^&7K==ioj*Yh5|EFZrJ^zJJuovtY|ViD;`{e|8Svl$2rm?DKaJ zao_L7?=!;QtBsE*zsFOrS5kC&QqE1&k$f1)>6;>K6xw)(l|&KqWpTnuA$Yntm^cBa zYupqeDJm&KQ{iR*16Jlw^EW2&&a~&)I&=Cf_Y|dUD3?>h&2y&xi2Q}q>do1y_L=q* zw)Y31{fwHXPRs0=E`G{iooO$SwSn&aV$AlIdkD`6q;(LRnIZ^A091R4WH3vmy+YNs ofkZ)(SmpI2XCY#j{pDw diff --git a/AlphaFS/obj/Net452 Debug/TempPE/Resources.Designer.cs.dll b/AlphaFS/obj/Net452 Debug/TempPE/Resources.Designer.cs.dll deleted file mode 100644 index 605a133418d49a3edf0a5da6e80a3787aab5e12e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9216 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 diff --git a/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs b/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs deleted file mode 100644 index e69de29..0000000 diff --git a/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs b/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs deleted file mode 100644 index e69de29..0000000 diff --git a/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs b/AlphaFS/obj/Net452 Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs deleted file mode 100644 index e69de29..0000000 diff --git a/Bin/Debug/Net35/AlphaFS.XML b/Bin/Debug/Net35/AlphaFS.XML deleted file mode 100644 index b0f27e9..0000000 --- a/Bin/Debug/Net35/AlphaFS.XML +++ /dev/null @@ -1,21563 +0,0 @@ - - - - AlphaFS - - - -

Information about an alternate data stream. - - - - Gets the name of the alternate data stream. - This value is an empty string for the default stream (:$DATA), and for any other data stream it contains the name of the stream. - The name of the stream. - - - Gets the size of the stream. - - - Gets the full path to the stream. - - This is a path in long path format that can be passed to to open the stream if - or - is specified. - - The full path to the stream in long path format. - - - Returns the hash code for this instance. - A 32-bit signed integer that is the hash code for this instance. - - - Indicates whether this instance and a specified object are equal. - The object to compare with the current instance. - - true if and this instance are the same type and represent the same value; otherwise, false. - - - - Equality operator. - The first operand. - The second operand. - The result of the operation. - - - Inequality operator. - The first operand. - The second operand. - The result of the operation. - - - The structure contains stream header data. - - - - Initializes a new instance of the class. - The stream ID. - The name. - - - Gets the size of the data in the substream, in bytes. - The size of the data in the substream, in bytes. - - - Gets a string that specifies the name of the alternative data stream. - A string that specifies the name of the alternative data stream. - - - Gets the type of the data in the stream. - The type of the data in the stream. - - - Gets the attributes of the data to facilitate cross-operating system transfer. - Attributes of the data to facilitate cross-operating system transfer. - - - Callback used by CopyFileXxx and MoveFileXxx to report progress about the copy/move operation. - - - Exposes static methods for creating, moving, and enumerating through directories and subdirectories. - This class cannot be inherited. - - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - A class with the status of the Move action. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move a Non-/Transacted file or directory including its children to a new location, - or can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless contains . - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an IOException. - - - A class with the status of the Copy or Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied/moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - Indicates the format of the path parameter(s). - - - Delete empty subdirectories from the specified directory. - - - - - - - A FileSystemEntryInfo instance. Use either or , not both. - The transaction. - The name of the directory to remove empty subdirectories from. Use either or , not both. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - When indicates the method is called externally. - Indicates the format of the path parameter(s). - - - Deletes an empty directory from a specified path. - - - - - - - - The name of the empty directory to remove. This directory must be writable and empty. - - - Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The name of the empty directory to remove. This directory must be writable and empty. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The transaction. - The name of the empty directory to remove. This directory must be writable and empty. - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The transaction. - The name of the empty directory to remove. This directory must be writable and empty. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - Indicates the format of the path parameter(s). - - - Deletes the specified directory and, if indicated, any subdirectories in the directory. - The RemoveDirectory function marks a directory for deletion on close. Therefore, the directory is not removed until the last handle to the directory is closed. - - - - - - - - A FileSystemEntryInfo instance. Use either or , not both. - The transaction. - The name of the directory to remove. Use either or , not both. - to remove all files and subdirectories recursively; otherwise only the top level empty directory. - overrides read only attribute of files and directories. - requires the directory must be empty. - does not throw an Exception when the file system object does not exist. - Indicates the format of the path parameter(s). - - - Creates all directories and subdirectories in the specified path unless they already exist. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all the directories in the specified path, unless the already exist, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all directories and subdirectories in the specified path unless they already exist. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all the directories in the specified path, unless the already exist, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates a new directory with the attributes of a specified template directory (if one is specified). - If the underlying file system supports security on files and directories, the function applies the specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - Returns an object that represents the directory at the specified path. - This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. May be to indicate that no template should be used. - The access control to apply to the directory, may be null. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of directory names that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file instances instances that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances instances that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file system entries in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The path to test. - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The path to test. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The transaction. - The path to test. - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The transaction. - The path to test. - Indicates the format of the path parameter(s). - - - Returns the names of subdirectories (including their paths) in the specified directory. - An array of the full names (including paths) of subdirectories in the specified path, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - - Returns the names of subdirectories (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) of the subdirectories that match the search pattern in the specified directory, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of the subdirectories (including their paths) that match the specified search pattern in the specified directory, and optionally searches subdirectories. - An array of the full names (including paths) of the subdirectories that match the specified criteria, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of subdirectories (including their paths) in the specified directory. - An array of the full names (including paths) of subdirectories in the specified path, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - - Returns the names of subdirectories (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) of the subdirectories that match the search pattern in the specified directory, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of the subdirectories (including their paths) that match the specified search pattern in the specified directory, and optionally searches subdirectories. - An array of the full names (including paths) of the subdirectories that match the specified criteria, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of files (including their paths) in the specified directory. - An array of the full names (including paths) for the files in the specified directory, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - - Returns the names of files (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of files (including their paths) that match the specified search pattern in the current directory, and optionally searches subdirectories. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern and option, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of files (including their paths) in the specified directory. - An array of the full names (including paths) for the files in the specified directory, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - - Returns the names of files (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of files (including their paths) that match the specified search pattern in the current directory, and optionally searches subdirectories. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern and option, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - - - Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The directory for which to obtain access date and time information. - - - Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The transaction. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The transaction. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The transaction. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The transaction. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The directory for which to obtain write date and time information. - - - Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The transaction. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The transaction. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The transaction. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The transaction. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Check if the directory has permission inheritance enabled. - if permission inheritance is enabled, if permission inheritance is disabled. - The full path to the directory to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Check if the directory has permission inheritance enabled. - The full path to the directory to check. - if permission inheritance is enabled, if permission inheritance is disabled. - - - Gets a object that encapsulates the access control list (ACL) entries for the specified directory. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a directory containing a object that describes the file's access control list (ACL) information. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - The path to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for the specified directory. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a directory containing a object that describes the file's access control list (ACL) information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - The path to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for the specified directory handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a directory containing a object that describes the directory's access control list (ACL) information. - - - [AlphaFS] Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory handle. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - A to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - - Gets the current working directory of the application. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path of the current working directory without a trailing directory separator. - - - - Sets the application's current working directory to the specified directory. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path to which the current working directory is set. - - - - Sets the application's current working directory to the specified directory. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path to which the current working directory is set. - Indicates the format of the path parameter. - - - Returns the names of all files and subdirectories in the specified directory. - An string[] array of the names of files and subdirectories in the specified directory. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory for which file and subdirectory names are returned. - - - Returns an array of file system entries that match the specified search criteria. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The path to be searched. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Gets an array of all the file names and directory names that match a in a specified path, and optionally searches subdirectories. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of all files and subdirectories in the specified directory. - An string[] array of the names of files and subdirectories in the specified directory. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory for which file and subdirectory names are returned. - - - Returns an array of file system entries that match the specified search criteria. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The path to be searched. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Gets an array of all the file names and directory names that match a in a specified path, and optionally searches subdirectories. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The path of a file or directory. - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The path of a file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - Indicates the format of the path parameter(s). - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - Indicates the format of the path parameter(s). - - - Retrieves the names of the logical drives on this computer in the form "<drive letter>:\". - An array of type that represents the logical drives on a computer. - - - [AlphaFS] Retrieves the names of the logical drives on this computer in the form "<drive letter>:\". - An array of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - [AlphaFS] Enumerates the drive names of all logical drives on a computer. - An IEnumerable of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - Enumerates the drive names of all logical drives on a computer. - An IEnumerable of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The path for which to retrieve the parent directory. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - - - [AlphaFS] Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a object to the specified directory. - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - Note that unlike this method does not automatically - determine what parts of the specified instance has been modified. Instead, the - parameter is used to specify what entries from to apply to . - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - Note that unlike this method does not automatically - determine what parts of the specified instance has been modified. Instead, the - parameter is used to specify what entries from to apply to . - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a object to the specified directory. - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - Indicates the format of the path parameter(s). - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - Indicates the format of the path parameter(s). - A containing the value to set for the creation date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The transaction. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The transaction. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - A path that describes a directory to compress. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - A path that describes a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to compress. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - The transaction. - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - The transaction. - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - A path that describes a directory to decompress. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - A path that describes a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to decompress. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - The transaction. - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - The transaction. - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - A path to a directory to decompress. - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - A path to a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - The transaction. - A path to a directory to decompress. - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - The transaction. - Indicates the format of the path parameter(s). - A path to a directory to decompress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - A path to a directory to compress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - A path to a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - The transaction. - A path to a directory to compress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - The transaction. - A path to a directory to compress. - Indicates the format of the path parameter(s). - - - Compress/decompress Non-/Transacted files/directories. - - - - - - - The transaction. - A path that describes a directory to compress. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - compress, when decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - to decrypt the directory recursively. only decrypt the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - to decrypt the directory recursively. only decrypt the directory. - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - Indicates the format of the path parameter(s). - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - to encrypt the directory recursively. only encrypt the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - to encrypt the directory recursively. only encrypt the directory. - - - [AlphaFS] Disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and disables encryption by writing: "Disable=1" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to disable encryption. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and disables encryption by writing: "Disable=1" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to disable encryption. - - - [AlphaFS] Enables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables encryption by writing: "Disable=0" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables encryption by writing: "Disable=0" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - - - Enables/disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables/disables encryption by writing: "Disable=0" or "Disable=1". - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - enabled encryption, disables encryption. - Indicates the format of the path parameter(s). - - - Decrypts/encrypts a directory recursively so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - encrypt, decrypt. - to decrypt the directory recursively. only decrypt files and directories in the root of . - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory handle specified. - An IEnumerable of records for each file system entry in the specified diretory. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of information about files in the directory handle specified. - An IEnumerable of records for each file system entry in the specified diretory. - - Either use or , not both. - - The number of files that are returned for each call to GetFileInformationByHandleEx depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle will resume the enumeration operation after the last file is returned. - - - The transaction. - An open handle to the directory from which to retrieve information. - A path to the directory. - The mode with which to open a handle to the directory. - suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The path to the directory to enumerate streams of. - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The path to the directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The transaction. - The path to the directory to enumerate streams of. - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The transaction. - The path to the directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Backs up (export) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The directory being backed up is not decrypted; it is backed up in its encrypted state. - If the caller does not have access to the key for the file, the caller needs to export encrypted files. See . - To backup an encrypted directory call one of the overloads and specify the directory to backup along with the destination stream of the backup data. - This function is intended for the backup of only encrypted directories; see for backup of unencrypted directories. - Note that this method does not back up the files inside the directory, only the directory entry itself. - - - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - - - [AlphaFS] Backs up (export) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The directory being backed up is not decrypted; it is backed up in its encrypted state. - If the caller does not have access to the key for the file, the caller needs to export encrypted files. See . - To backup an encrypted directory call one of the overloads and specify the directory to backup along with the destination stream of the backup data. - This function is intended for the backup of only encrypted directories; see for backup of unencrypted directories. - Note that this method does not back up the files inside the directory, only the directory entry itself. - - - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - The path format of the parameter. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - The path format of the parameter. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - If set to a hidden directory will be overwritten on import. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - If set to a hidden directory will be overwritten on import. - The path format of the parameter. - - - Exposes instance methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited. - - - Refreshes the state of the EntryInfo instance. - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - to decrypt the directory recursively. only decrypt files and directories in the root of the directory. - - - [AlphaFS] Disables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories below the indicated directory. - on success, otherwise. - This method will create/change the file "Desktop.ini" and wil set Encryption value: "Disable=0" - - - [AlphaFS] Enables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories below the indicated directory. - on success, otherwise. - This method will create/change the file "Desktop.ini" and wil set Encryption value: "Disable=1" - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - to encrypt the directory recursively. only encrypt files and directories in the root of the directory. - - - [AlphaFS] Deletes empty subdirectories from the instance. - - - [AlphaFS] Deletes empty subdirectories from the instance. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the instance. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Disables compression of the specified directory and the files in it. - - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. - However, newly created files and directories will be uncompressed. - - - - [AlphaFS] Enables compression of the specified directory and the files in it. - - This method enables the directory-compression attribute. It will not compress the current contents of the directory. - However, newly created files and directories will be compressed. - - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Copies a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely copied. - - - - - - - The destination directory path. - - - [AlphaFS] Copies a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely copied. - - - - - - - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - Returns a new directory, or an overwrite of an existing directory if is not . - If the directory exists and contains , an is thrown. - - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - Returns a new directory, or an overwrite of an existing directory if is not . - If the directory exists and contains , an is thrown. - - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - - - Moves a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move a Non-/Transacted file or directory including its children to a new location, - or can be specified, and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless contains . - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an IOException. - - - A class with details of the Copy or Move action. - - - - - - - The destination directory path. - that specify how the file is to be copied. This parameter can be . - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Returns the retrieved long full path. - Indicates the format of the path parameter(s). - - - Returns the original path that was passed by the user. - A string that represents this object. - - - Applies access control list (ACL) entries described by a object to the directory described by the current DirectoryInfo object. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the directory described by the current DirectoryInfo object. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Refreshes the state of the object. - - - Returns an array of strongly typed entries representing all the files and subdirectories in a directory. - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Retrieves an array of strongly typed objects representing the files and subdirectories that match the specified search criteria. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Retrieves an array of strongly typed objects representing the files and subdirectories that match the specified search criteria. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Returns a file list from the current directory. - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns a file list from the current directory matching the given search pattern. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns a file list from the current directory matching the given search pattern and using a value to determine whether to search subdirectories. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns the subdirectories of the current directory. - An array of objects. - If there are no subdirectories, this method returns an empty array. This method is not recursive. - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - - Returns an array of directories in the current matching the given search criteria. - An array of type matching . - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an array of directories in the current matching the given search criteria and using a value to determine whether to search subdirectories. - An array of type matching . - If there are no subdirectories, or no subdirectories match the searchPattern parameter, this method returns an empty array. - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Gets a object that encapsulates the access control list (ACL) entries for the directory described by the current DirectoryInfo object. - A object that encapsulates the access control rules for the directory. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for the directory described by the current object. - One of the values that specifies the type of access control list (ACL) information to receive. - A object that encapsulates the access control rules for the file described by the path parameter. - - - Returns an enumerable collection of file system information in the current directory. - An enumerable collection of file system information in the current directory. - - - - - - - - - Returns an enumerable collection of file system information that matches a specified search pattern. - An enumerable collection of file system information objects that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file system information that matches a specified search pattern and search subdirectory option. - An enumerable collection of file system information objects that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file system information in the current directory. - An enumerable collection of file system information in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system information that matches a specified search pattern. - An enumerable collection of file system information objects that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of file information in the current directory. - An enumerable collection of the files in the current directory. - - - - - - - - - Returns an enumerable collection of file information that matches a search pattern. - An enumerable collection of files that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file information that matches a specified search pattern and search subdirectory option. - An enumerable collection of files that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns an enumerable collection of file information in the current directory. - An enumerable collection of the files in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of file information that matches a search pattern. - An enumerable collection of files that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of directory information in the current directory. - An enumerable collection of directories in the current directory. - - - - - - - - - Returns an enumerable collection of directory information that matches a specified search pattern. - An enumerable collection of directories that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of directory information that matches a specified search pattern and search subdirectory option. - An enumerable collection of directories that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory information in the current directory. - An enumerable collection of directories in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of directory information that matches a specified search pattern. - An enumerable collection of directories that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Deletes this if it is empty. - - - - - - - - - Deletes this instance of a , specifying whether to delete subdirectories and files. - - If the has no files or subdirectories, this method deletes the even if recursive is . - Attempting to delete a that is not empty when recursive is false throws an . - - - - - - - - to delete this directory, its subdirectories, and all files; otherwise, . - - - [AlphaFS] Deletes this instance of a , specifying whether to delete files and subdirectories. - - If the has no files or subdirectories, this method deletes the even if recursive is . - Attempting to delete a that is not empty when recursive is false throws an . - - - - - - - - to delete this directory, its subdirectories, and all files; otherwise, . - ignores read only attribute of files and directories. - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The security to apply. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - The specified path. This cannot be a different disk volume. - When compresses the directory. - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The security to apply. - When compresses the directory. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The path of the directory to use as a template when creating the new directory. - The specified path. This cannot be a different disk volume. - When compresses the directory. - The security to apply. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the DirectoryInfo class. - The last directory specified in path as an object. - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - The specified path. This cannot be a different disk volume or Universal Naming Convention (UNC) name. - The path of the directory to use as a template when creating the new directory. - The security to apply. - When compresses the directory. - - - Creates a directory. - If the directory already exists, this method does nothing. - - - Creates a directory using a object. - The access control to apply to the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Creates a directory using a object. - When compresses the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Creates a directory using a object. - The access control to apply to the directory. - When compresses the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Returns an enumerable collection of instances for the directory. - An enumerable collection of instances for the directory. - - - Initializes a new instance of the class on the specified path. - The path on which to create the . - - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - The path parameter can be a file name, including a file on a Universal Naming Convention (UNC) share. - - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The path on which to create the . - Indicates the format of the path parameter(s). - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Special internal implementation. - The transaction. - The full path on which to create the . - Not used. - Not used. - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The transaction. - The path on which to create the . - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The transaction. - The path on which to create the . - Indicates the format of the path parameter(s). - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - Gets a value indicating whether the directory exists. - - The property returns if any error occurs while trying to determine if the - specified directory exists. - This can occur in situations that raise exceptions such as passing a directory name with invalid characters or too many - characters, - a failing or missing disk, or if the caller does not have permission to read the directory. - - if the directory exists; otherwise, . - - - Gets the name of this instance. - The directory name. - - This Name property returns only the name of the directory, such as "Bin". - To get the full path, such as "c:\public\Bin", use the FullName property. - - - - Gets the parent directory of a specified subdirectory. - The parent directory, or null if the path is null or if the file path denotes a root (such as "\", "C:", or * "\\server\share"). - - - Gets the root portion of the directory. - An object that represents the root of the directory. - - - Indicates the operation to be performed when opening a file using the OpenEncryptedFileRaw. - - - (0) Open the file for export (backup). - - - (1) The file is being opened for import (restore). - - - (2) Import (restore) a directory containing encrypted files. This must be combined with one of the previous two flags to indicate the operation. - - - (4) Overwrite a hidden file on import. - - - Defines values that are used with the FindFirstStreamW function to specify the information level of the returned data. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - The FindFirstStreamW function retrieves standard stream information. The data is returned in a structure. - - - Used to determine valid enumeration values. All supported enumeration values are less than FindStreamInfoMaxInfoLevel. - - - Specifies control options that filter the device information elements that are added to the device information set. - - - DIGCF_DEFAULT - Return only the device that is associated with the system default device interface, if one is set, for the specified device interface classes. - - - - DIGCF_PRESENT - Return only devices that are currently present. - - - - DIGCF_ALLCLASSES - Return a list of installed devices for the specified device setup classes or device interface classes. - - - - DIGCF_PROFILE - Return only devices that are a part of the current hardware profile. - - - - DIGCF_DEVICEINTERFACE - - Return devices that support device interfaces for the specified device interface classes. - This flag must be set in the Flags parameter if the Enumerator parameter specifies a Device Instance ID. - - - - - FILE_INFO_BY_HANDLE_CLASS - Identifies the type of file information that GetFileInformationByHandleEx should retrieve or SetFileInformationByHandle should set. - - - - FILE_BASIC_INFO - Minimal information for the file should be retrieved or set. Used for file handles. - - - - FILE_ID_BOTH_DIR_INFO - Files in the specified directory should be retrieved. Used for directory handles. - Use only when calling GetFileInformationByHandleEx. - - The number of files returned for each call to GetFileInformationByHandleEx - depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle - will resume the enumeration operation after the last file is returned. - - - - - Additional flags that control the search. - - - No additional flags used. - - - Searches are case-sensitive. - - - Uses a larger buffer for directory queries, which can increase performance of the find operation. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FINDEX_INFO_LEVELS Enumeration - Defines values that are used with the FindFirstFileEx function to specify the information level of the returned data. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - - A standard set of attribute is returned in a structure. - - - The FindFirstFileEx function does not query the short file name, improving overall enumeration speed. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FINDEX_SEARCH_OPS Enumeration - Defines values that are used with the FindFirstFileEx function to specify the type of filtering to perform. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - - The search for a file that matches a specified file name. - The lpSearchFilter parameter of FindFirstFileEx must be NULL when this search operation is used. - - - - This is an advisory flag. If the file system supports directory filtering, - the function searches for a file that matches the specified name and is also a directory. - If the file system does not support directory filtering, this flag is silently ignored. -   - - The lpSearchFilter parameter of the FindFirstFileEx function must be NULL when this search value is used. - If directory filtering is desired, this flag can be used on all file systems, - but because it is an advisory flag and only affects file systems that support it, - the application must examine the file attribute data stored in the lpFindFileData parameter - of the FindFirstFileEx function to determine whether the function has returned a handle to a directory. - - - - - This filtering type is not available. - For more information, see Device Interface Classes. - - - Enum for struct ChangeErrorMode. - - - Use the system default, which is to display all error dialog boxes. - - - The system does not display the critical-error-handler message box. Instead, the system sends the error to the calling process/thread. - - - The system does not display the Windows Error Reporting dialog. - - - The system automatically fixes memory alignment faults and makes them invisible to the application. It does this for the calling process and any descendant processes. This feature is only supported by certain processor architectures. - - - The system does not display a message box when it fails to find a file. Instead, the error is returned to the calling process/thread. - - - Flags for SetupDiGetDeviceRegistryProperty(). - - - SPDRP_DEVICEDESC - Represents a description of a device instance. - - - - SPDRP_HARDWAREID - Represents the list of hardware identifiers for a device instance. - - - - SPDRP_COMPATIBLEIDS - Represents the list of compatible identifiers for a device instance. - - - - SPDRP_CLASS - Represents the name of the service that is installed for a device instance. - - - - SPDRP_CLASS - Represents the name of the device setup class that a device instance belongs to. - - - - SPDRP_CLASSGUID - Represents the of the device setup class that a device instance belongs to. - - - - SPDRP_DRIVER - Represents the registry entry name of the driver key for a device instance. - - - - SPDRP_MFG - Represents the name of the manufacturer of a device instance. - - - - SPDRP_FRIENDLYNAME - Represents the friendly name of a device instance. - - - - SPDRP_LOCATION_INFORMATION - Represents the bus-specific physical location of a device instance. - - - - SPDRP_PHYSICAL_DEVICE_LOCATION - Encapsulates the physical device location information provided by a device's firmware to Windows. - - - - SPDRP_ENUMERATOR_NAME - Represents the name of the enumerator for a device instance. - - - - SPDRP_LOCATION_PATHS - Represents the location of a device instance in the device tree. - - - - SPDRP_BASE_CONTAINERID - Represents the value of the base container identifier (ID) .The Windows Plug and Play (PnP) manager assigns this value to the device node (devnode). - - - - Volume Attributes used by the GetVolumeInfo() function. - - - No VolumeInfo attributes. - - - FILE_CASE_SENSITIVE_SEARCH - The specified volume supports case-sensitive file names. - - - - FILE_CASE_PRESERVED_NAMES - The specified volume supports preserved case of file names when it places a name on disk. - - - - FILE_UNICODE_ON_DISK - The specified volume supports Unicode in file names as they appear on disk. - - - - FILE_PERSISTENT_ACLS - - The specified volume preserves and enforces access control lists (ACL). - For example, the NTFS file system preserves and enforces ACLs, and the FAT file system does not. - - - - - FILE_FILE_COMPRESSION - The specified volume supports file-based compression. - - - - FILE_VOLUME_QUOTAS - The specified volume supports disk quotas. - - - - FILE_SUPPORTS_SPARSE_FILES - The specified volume supports sparse files. - - - - FILE_SUPPORTS_REPARSE_POINTS - The specified volume supports re-parse points. - - - - (does not appear on MSDN) - - - FILE_VOLUME_IS_COMPRESSED - The specified volume is a compressed volume, for example, a DoubleSpace volume. - - - - FILE_SUPPORTS_OBJECT_IDS - The specified volume supports object identifiers. - - - - FILE_SUPPORTS_ENCRYPTION - The specified volume supports the Encrypted File System (EFS). For more information, see File Encryption. - - - - FILE_NAMED_STREAMS - The specified volume supports named streams. - - - - FILE_READ_ONLY_VOLUME - The specified volume is read-only. - - - - FILE_SEQUENTIAL_WRITE_ONCE - The specified volume is read-only. - - - - FILE_SUPPORTS_TRANSACTIONS - The specified volume supports transactions.For more information, see About KTM. - - - - FILE_SUPPORTS_HARD_LINKS - The specified volume supports hard links. For more information, see Hard Links and Junctions. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_EXTENDED_ATTRIBUTES - - The specified volume supports extended attributes. An extended attribute is a piece of application-specific metadata - that an application can associate with a file and is not part of the file's data. - - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_OPEN_BY_FILE_ID - The file system supports open by FileID. For more information, see FILE_ID_BOTH_DIR_INFO. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_USN_JOURNAL - The specified volume supports update sequence number (USN) journals. For more information, see Change Journal Records. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - Defines values that are used with the GetFileAttributesEx and GetFileAttributesTransacted functions to specify the information level of the returned data. - - - The GetFileAttributesEx or GetFileAttributesTransacted function retrieves a standard set of attribute information. The data is returned in a WIN32_FILE_ATTRIBUTE_DATA structure. - - - Opens an encrypted file in order to backup (export) or restore (import) the file. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - The name of the file to be opened. - The operation to be performed. - [out] The address of a context block that must be presented in subsequent calls to - ReadEncryptedFileRaw, WriteEncryptedFileRaw, or CloseEncryptedFileRaw. - - - Closes an encrypted file after a backup or restore operation, and frees associated system resources. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - A pointer to a system-defined context block. The OpenEncryptedFileRaw function returns the context block. - - - Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is intended to implement backup and restore functionality, while maintaining files in their encrypted state. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is intended to implement backup and restore functionality, while maintaining files in their encrypted state. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Returns a pointer to an IQueryAssociations object. - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Searches for and retrieves a file or protocol association-related string from the registry. - Return value Type: HRESULT. Returns a standard COM error value, including the following: S_OK, E_POINTER and S_FALSE. - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - Exposes methods that simplify the process of retrieving information stored in the registry in association with defining a file type or protocol and associating it with an application. - - - Initializes the IQueryAssociations interface and sets the root key to the appropriate ProgID. - If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Searches for and retrieves a file or protocol association-related string from the registry. - A standard COM error value, including the following: S_OK, E_POINTER, S_FALSE - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Determines whether a path to a file system object such as a file or folder is valid. - if the file exists; otherwise, . Call GetLastError for extended error information. - - This function tests the validity of the path. - A path specified by Universal Naming Convention (UNC) is limited to a file only; that is, \\server\share\file is permitted. - A network share path to a server or server share is not permitted; that is, \\server or \\server\share. - This function returns FALSE if a mounted remote drive is out of service. - - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - Converts a file URL to a Microsoft MS-DOS path. - Type: HRESULT - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Creates a path from a file URL. - Type: HRESULT - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Converts a Microsoft MS-DOS path to a canonicalized URL. - Type: HRESULT - Returns S_FALSE if pszPath is already in URL format. In this case, pszPath will simply be copied to pszUrl. - Otherwise, it returns S_OK if successful or a standard COM error value if not. - - - UrlCreateFromPath does not support extended paths. These are paths that include the extended-length path prefix "\\?\". - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Tests whether a URL is a specified type. - - Type: BOOL - For all but one of the URL types, UrlIs returns if the URL is the specified type, otherwise. - If UrlIs is set to , UrlIs will attempt to determine the URL scheme. - If the function is able to determine a scheme, it returns , or . - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Destroys an icon and frees any memory the icon occupied. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Retrieves information about an object in the file system, such as a file, folder, directory, or drive root. - You should call this function from a background thread. Failure to do so could cause the UI to stop responding. - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Creates a new transaction object. - - - Use the function to close the transaction handle. If the last transaction handle is closed - beforea client calls the CommitTransaction function with the transaction handle, then KTM rolls back the transaction. - Minimum supported client: Windows Vista - Minimum supported server:Windows Server 2008 - - - If the function succeeds, the return value is a handle to the transaction. - If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call the GetLastError - function. - - - - Requests that the specified transaction be committed. - - You can commit any transaction handle that has been opened or created using the TRANSACTION_COMMIT permission; any - application can commit a transaction, not just the creator. - This function can only be called if the transaction is still active, not prepared, pre-prepared, or rolled back. - Minimum supported client: Windows Vista - Minimum supported server:Windows Server 2008 - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is 0 (zero). To get extended error information, call the GetLastError function. - - - - - Requests that the specified transaction be rolled back. This function is synchronous. - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call the GetLastError function. - - - - Closes an open object handle. - - The CloseHandle function closes handles to the following objects: - Access token, Communications device, Console input, Console screen buffer, Event, File, File mapping, I/O completion port, - Job, Mailslot, Memory resource notification, Mutex, Named pipe, Pipe, Process, Semaphore, Thread, Transaction, Waitable - timer. - SetLastError is set to . - Minimum supported client: Windows 2000 Professional [desktop apps | Windows Store apps] - Minimum supported server: Windows 2000 Server [desktop apps | Windows Store apps] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - If the application is running under a debugger, the function will throw an exception if it receives either a handle value - that is not valid or a pseudo-handle value.This can happen if you close a handle twice, or if you call CloseHandle on a handle - returned by the FindFirstFile function instead of calling the FindClose function. - - - - - Copies an existing file to a new file, notifying the application of its progress through a callback function. - - - This function fails with ERROR_ACCESS_DENIED if the destination file already exists and has the FILE_ATTRIBUTE_HIDDEN or - FILE_ATTRIBUTE_READONLY attribute set. - This function preserves extended attributes, OLE structured storage, NTFS file system alternate data streams, security - resource attributes, and file attributes. - Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: - Security resource attributes (ATTRIBUTE_SECURITY_INFORMATION) for the existing file are not copied to the new file until - Windows 8 and Windows Server 2012. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Filename of the existing file. - Filename of the new file. - The progress routine. - The data. - [out] The pb cancel. - The copy flags. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Copies an existing file to a new file as a transacted operation, notifying the application of its progress through a callback - function. - - - This function fails with ERROR_ACCESS_DENIED if the destination file already exists and has the FILE_ATTRIBUTE_HIDDEN or - FILE_ATTRIBUTE_READONLY attribute set. - This function preserves extended attributes, OLE structured storage, NTFS file system alternate data streams, security - resource attributes, and file attributes. - Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: - Security resource attributes (ATTRIBUTE_SECURITY_INFORMATION) for the existing file are not copied to the new file until - Windows 8 and Windows Server 2012. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical - disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is an open handle to the specified file, device, named pipe, or mail slot. If the - function fails, the return value is Win32Errors.ERROR_INVALID_HANDLE. To get extended error information, call GetLastError. - - - - - Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical - disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is an open handle to the specified file, device, named pipe, or mail slot. If the - function fails, the return value is Win32Errors.ERROR_INVALID_HANDLE". To get extended error information, call GetLastError. - - - - Creates or opens a named or unnamed file mapping object for a specified file. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is a handle to the newly created file mapping object. If the function fails, the return - value is . - - - - - Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only - for files, not directories. - - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - - Establishes a hard link between an existing file and a new file as a transacted operation. This function is only supported on the - NTFS file system, and only for files, not directories. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Creates a symbolic link. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - The unmanaged prototype contains a return directive because the CreateSymbolicLink API function returns BOOLEAN, a one-byte data type. - The default marshaling for bool is four bytes (to allow seamless integration with BOOL return values). - If you were to use the default marshaling for BOOLEAN values, it's likely that you will get erroneous results. - The return directive forces PInvoke to marshal just one byte of the return value. - Source: http://www.informit.com/guides/content.aspx?g=dotnet&seqNum=762&ns=16196 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Creates a symbolic link as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - The unmanaged prototype contains a return directive because the CreateSymbolicLink API function returns BOOLEAN, a one-byte data type. - The default marshaling for bool is four bytes (to allow seamless integration with BOOL return values). - If you were to use the default marshaling for BOOLEAN values, it's likely that you will get erroneous results. - The return directive forces PInvoke to marshal just one byte of the return value. - Source: http://www.informit.com/guides/content.aspx?g=dotnet&seqNum=762&ns=16196 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Decrypts an encrypted file or directory. - - The DecryptFile function requires exclusive access to the file being decrypted, and will fail if another process is using the file. - If the file is not encrypted, DecryptFile simply returns a nonzero value, which indicates success. If lpFileName specifies a read- - only file, the function fails and GetLastError returns ERROR_FILE_READ_ONLY. If lpFileName specifies a directory that contains a - read-only file, the functions succeeds but the directory is not decrypted. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Deletes an existing file. - - If an application attempts to delete a file that does not exist, the DeleteFile function fails with ERROR_FILE_NOT_FOUND. - - If the file is a read-only file, the function fails with ERROR_ACCESS_DENIED. - - If the path points to a symbolic link, the symbolic link is deleted, not the target. To delete a target, you must call CreateFile - and specify FILE_FLAG_DELETE_ON_CLOSE. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Deletes an existing file as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - - Encrypts a file or directory. All data streams in a file are encrypted. All new files created in an encrypted directory are - encrypted. - - - The EncryptFile function requires exclusive access to the file being encrypted, and will fail if another process is using the file. - If the file is already encrypted, EncryptFile simply returns a nonzero value, which indicates success. If the file is compressed, - EncryptFile will decompress the file before encrypting it. If lpFileName specifies a read-only file, the function fails and - GetLastError returns ERROR_FILE_READ_ONLY. If lpFileName specifies a directory that contains a read-only file, the functions - succeeds but the directory is not encrypted. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Disables or enables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories - below the indicated directory. - - - EncryptionDisable() disables encryption of directories and files. It does not affect the visibility of files with the - FILE_ATTRIBUTE_SYSTEM attribute set. This method will create/change the file "Desktop.ini" and wil set Encryption value: - "Disable=0|1". - - Minimum supported client: Windows XP Professional [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves the encryption status of the specified file. - Minimum supported client: Windows XP Professional [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Closes a file search handle opened by the FindFirstFile, FindFirstFileEx, FindFirstFileNameW, FindFirstFileNameTransactedW, - FindFirstFileTransacted, FindFirstStreamTransactedW, or FindFirstStreamW functions. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Searches a directory for a file or subdirectory with a name and attributes that match those specified. - A trailing backslash is not allowed and will be removed. - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose, and the - lpFindFileData parameter contains information about the first file or directory found. If the function fails or fails to locate - files from the search string in the lpFileName parameter, the return value is INVALID_HANDLE_VALUE and the contents of - lpFindFileData are indeterminate. To get extended error information, call the GetLastError function. - - - - - Searches a directory for a file or subdirectory with a name that matches a specific name as a transacted operation. - - A trailing backslash is not allowed and will be removed. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose, and the - lpFindFileData parameter contains information about the first file or directory found. If the function fails or fails to locate - files from the search string in the lpFileName parameter, the return value is INVALID_HANDLE_VALUE and the contents of - lpFindFileData are indeterminate. To get extended error information, call the GetLastError function. - - - - - Creates an enumeration of all the hard links to the specified file. The FindFirstFileNameW function returns a handle to the - enumeration that can be used on subsequent calls to the FindNextFileNameW function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle that can be used with the FindNextFileNameW function or closed with - the FindClose function. If the function fails, the return value is INVALID_HANDLE_VALUE (0xffffffff). To get extended error - information, call the GetLastError function. - - - - - Creates an enumeration of all the hard links to the specified file as a transacted operation. The function returns a handle to the - enumeration that can be used on subsequent calls to the FindNextFileNameW function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle that can be used with the FindNextFileNameW function or closed with - the FindClose function. If the function fails, the return value is INVALID_HANDLE_VALUE (0xffffffff). To get extended error - information, call the GetLastError function. - - - - - Continues a file search from a previous call to the FindFirstFile, FindFirstFileEx, or FindFirstFileTransacted functions. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero and the lpFindFileData parameter contains information about the next file or - directory found. If the function fails, the return value is zero and the contents of lpFindFileData are indeterminate. To get - extended error information, call the GetLastError function. If the function fails because no more matching files can be found, the - GetLastError function returns ERROR_NO_MORE_FILES. - - - - - Continues enumerating the hard links to a file using the handle returned by a successful call to the FindFirstFileName function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. If no matching files can be found, the GetLastError function returns ERROR_HANDLE_EOF. - - - - Flushes the buffers of a specified file and causes all buffered data to be written to a file. - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves the actual number of bytes of disk storage used to store a specified file. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is the low-order DWORD of the actual number of bytes of disk storage used to store the - specified file, and if lpFileSizeHigh is non-NULL, the function puts the high-order DWORD of that actual value into the DWORD - pointed to by that parameter. This is the compressed file size for compressed files, the actual file size for noncompressed files. - If the function fails, and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE. To get extended error information, call - GetLastError. If the return value is INVALID_FILE_SIZE and lpFileSizeHigh is non-NULL, an application must call GetLastError to - determine whether the function has succeeded (value is NO_ERROR) or failed (value is other than NO_ERROR). - - - - Retrieves the actual number of bytes of disk storage used to store a specified file as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is the low-order DWORD of the actual number of bytes of disk storage used to store the - specified file, and if lpFileSizeHigh is non-NULL, the function puts the high-order DWORD of that actual value into the DWORD - pointed to by that parameter. This is the compressed file size for compressed files, the actual file size for noncompressed files. - If the function fails, and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE. To get extended error information, call - GetLastError. If the return value is INVALID_FILE_SIZE and lpFileSizeHigh is non-NULL, an application must call GetLastError to - determine whether the function has succeeded (value is NO_ERROR) or failed (value is other than NO_ERROR). - - - - - Retrieves attributes for a specified file or directory. - - - The GetFileAttributes function retrieves file system attribute information. - GetFileAttributesEx can obtain other sets of file or directory attribute information. - Currently, GetFileAttributesEx retrieves a set of standard attributes that is a superset of the file system attribute - information. - When the GetFileAttributesEx function is called on a directory that is a mounted folder, it returns the attributes of the directory, - not those of the root directory in the volume that the mounted folder associates with the directory. To obtain the attributes of - the associated volume, call GetVolumeNameForVolumeMountPoint to obtain the name of the associated volume. Then use the resulting - name in a call to GetFileAttributesEx. The results are the attributes of the root directory on the associated volume. - Symbolic link behavior: If the path points to a symbolic link, the function returns attributes for the symbolic link. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves attributes for a specified file or directory. - - The GetFileAttributes function retrieves file system attribute information. - GetFileAttributesEx can obtain other sets of file or directory attribute information. - - Currently, GetFileAttributesEx retrieves a set of standard attributes that is a superset of the file system attribute information. - When the GetFileAttributesEx function is called on a directory that is a mounted folder, it returns the attributes of the directory, - not those of the root directory in the volume that the mounted folder associates with the directory. To obtain the attributes of - the associated volume, call GetVolumeNameForVolumeMountPoint to obtain the name of the associated volume. Then use the resulting - name in a call to GetFileAttributesEx. The results are the attributes of the root directory on the associated volume. - Symbolic link behavior: If the path points to a symbolic link, the function returns attributes for the symbolic link. - Transacted Operations - If a file is open for modification in a transaction, no other thread can open the file for modification until the transaction - is committed. Conversely, if a file is open for modification outside of a transaction, no transacted thread can open the file for - modification until the non-transacted handle is closed. If a non-transacted thread has a handle opened to modify a file, a call to - GetFileAttributesTransacted for that file will fail with an ERROR_TRANSACTIONAL_CONFLICT error. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves file information for the specified file. - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - Depending on the underlying network features of the operating system and the type of server connected to, - the GetFileInformationByHandle function may fail, return partial information, or full information for the given file. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves file information for the specified file. - - - Minimum supported client: Windows Vista [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2008 [desktop apps | Windows Store apps] - Redistributable: Windows SDK on Windows Server 2003 and Windows XP. - - The file. - The file information by handle class. - Information describing the file. - Size of the buffer. - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the - lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves file information for the specified file. - - Minimum supported client: Windows Vista [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2008 [desktop apps | Windows Store apps] - Redistributable: Windows SDK on Windows Server 2003 and Windows XP. - - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the - lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - The file. - The file information by handle class. - Information describing the file. - Size of the buffer. - - - - Retrieves the size of the specified file. - - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves the final path for the specified file. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Checks whether the specified address is within a memory-mapped file in the address space of the specified process. If so, the - function returns the name of the memory-mapped file. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Locks the specified file for exclusive access by the calling process. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero (TRUE). If the function fails, the return value is zero (FALSE). To get - extended error information, call GetLastError. - - - - Maps a view of a file mapping into the address space of a calling process. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is the starting address of the mapped view. If the function fails, the return value is - . - - - - - Moves a file or directory, including its children. - You can provide a callback function that receives progress notifications. - - - The MoveFileWithProgress function coordinates its operation with the link tracking service, so link sources can be tracked as they are moved. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Filename of the existing file. - Filename of the new file. - The progress routine. - The data. - The flags. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Moves an existing file or a directory, including its children, as a transacted operation. - You can provide a callback function that receives progress notifications. - - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - An application-defined callback function used with the CopyFileEx, MoveFileTransacted, and MoveFileWithProgress functions. - It is called when a portion of a copy or move operation is completed. - The LPPROGRESS_ROUTINE type defines a pointer to this callback function. - NativeCopyMoveProgressRoutine (NativeCopyMoveProgressRoutine) is a placeholder for the application-defined function name. - - - - Replaces one file with another file, with the option of creating a backup copy of the original file. The replacement file assumes the name of the replaced file and its identity. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Sets the attributes for a file or directory. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Sets the attributes for a file or directory as a transacted operation. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Sets the date and time that the specified file or directory was created, last accessed, or last modified. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Unlocks a region in an open file. Unlocking a region enables other processes to access the region. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Unmaps a mapped view of a file from the calling process's address space. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - The base address. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Retrieves information about the specified disk, including the amount of free space on the disk. - - - Symbolic link behavior: If the path points to a symbolic link, the operation is performed on the target. - If this parameter is a UNC name, it must include a trailing backslash (for example, "\\MyServer\MyShare\"). - Furthermore, a drive specification must have a trailing backslash (for example, "C:\"). - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Full pathname of the root file. - [out] The sectors per cluster. - [out] The bytes per sector. - [out] Number of free clusters. - [out] The total number of clusters. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, - the total amount of free space, and the total amount of free space available to the user that is associated with the calling - thread. - - - Symbolic link behavior: If the path points to a symbolic link, the operation is performed on the target. - The GetDiskFreeSpaceEx function returns zero (0) for lpTotalNumberOfFreeBytes and lpFreeBytesAvailable - for all CD requests unless the disk is an unwritten CD in a CD-RW drive. - If this parameter is a UNC name, it must include a trailing backslash, for example, "\\MyServer\MyShare\". - This parameter does not have to specify the root directory on a disk. - The function accepts any directory on a disk. - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Pathname of the directory. - [out] The free bytes available. - [out] The total number of in bytes. - [out] The total number of free in bytes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - - - - - Creates a new directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - - - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - An application can obtain a handle to a directory by calling with the FILE_FLAG_BACKUP_SEMANTICS - flag set. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Full pathname of the file. - The security attributes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Creates a new directory with the attributes of a specified template directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - The CreateDirectoryEx function allows you to create directories that inherit stream information from other directories. - This function is useful, for example, when you are using Macintosh directories, which have a resource stream - that is needed to properly identify directory contents as an attribute. - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - You can obtain a handle to a directory by calling the function with the FILE_FLAG_BACKUP_SEMANTICS - flag set. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Pathname of the template directory. - Full pathname of the file. - The security attributes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - - - - - Creates a new directory as a transacted operation, with the attributes of a specified template directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - The CreateDirectoryTransacted function allows you to create directories that inherit stream information from other - directories. - This function is useful, for example, when you are using Macintosh directories, which have a resource stream - that is needed to properly identify directory contents as an attribute. - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - You can obtain a handle to a directory by calling the function with the - FILE_FLAG_BACKUP_SEMANTICS flag set. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Pathname of the template directory. - Pathname of the new directory. - The security attributes. - The transaction. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - This function fails with ERROR_EFS_NOT_ALLOWED_IN_TRANSACTION if you try to create a - child directory with a parent directory that has encryption disabled. - - - - - Retrieves the current directory for the current process. - - - The RemoveDirectory function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - The length of the buffer for the current directory string, in TCHARs. The buffer length must include room for a terminating null character. - - A pointer to the buffer that receives the current directory string. This null-terminated string specifies the absolute path to the current directory. - To determine the required buffer size, set this parameter to NULL and the nBufferLength parameter to 0. - - - If the function succeeds, the return value specifies the number of characters that are written to the buffer, not including the terminating null character. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Deletes an existing empty directory. - - - The RemoveDirectory function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Full pathname of the file. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Deletes an existing empty directory as a transacted operation. - - - The RemoveDirectoryTransacted function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - Full pathname of the file. - The transaction. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Changes the current directory for the current process. - - - The path to the new current directory. This parameter may specify a relative path or a full path. In either case, the full path of the specified directory is calculated and stored as the current directory. - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - The CM_Connect_Machine function creates a connection to a remote machine. - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - Available in Microsoft Windows 2000 and later versions of Windows. - - Name of the unc server. - [out] The ph machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Get_Device_ID_Ex function retrieves the device instance ID for a specified device instance on a local or a remote machine. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. -   - Available in Microsoft Windows 2000 and later versions of Windows. - - The dn development instance. - The buffer. - Length of the buffer. - The ul flags. - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Disconnect_Machine function removes a connection to a remote machine. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - SetLastError is set to . - Available in Microsoft Windows 2000 and later versions of Windows. - - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Get_Parent_Ex function obtains a device instance handle to the parent node of a specified device node (devnode) in a local - or a remote machine's device tree. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - Available in Microsoft Windows 2000 and later versions of Windows. - - [out] The pdn development instance. - The dn development instance. - The ul flags. - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. - - If the operation completes successfully, the return value is nonzero. - If the operation fails or is pending, the return value is zero. To get extended error information, call GetLastError. - - - To retrieve a handle to the device, you must call the function with either the name of a device or - the name of the driver associated with a device. - To specify a device name, use the following format: \\.\DeviceName - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - The device. - The i/o control code. - Buffer for in data. - Size of the in buffer. - Buffer for out data. - Size of the out buffer. - [out] The bytes returned. - The overlapped. - - - Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. - - If the operation completes successfully, the return value is nonzero. - If the operation fails or is pending, the return value is zero. To get extended error information, call GetLastError. - - - To retrieve a handle to the device, you must call the function with either the name of a device or - the name of the driver associated with a device. - To specify a device name, use the following format: \\.\DeviceName - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - The device. - The i/o control code. - Buffer for in data. - Size of the in buffer. - Buffer for out data. - Size of the out buffer. - [out] The bytes returned. - The overlapped. - - - - The SetupDiDestroyDeviceInfoList function deletes a device information set and frees all associated memory. - - - SetLastError is set to . - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - - The function returns TRUE if it is successful. - Otherwise, it returns FALSE and the logged error can be retrieved with a call to GetLastError. - - - - - The SetupDiEnumDeviceInterfaces function enumerates the device interfaces that are contained in a device information set. - - - Repeated calls to this function return an structure for a different device - interface. - This function can be called repeatedly to get information about interfaces in a device information set that are - associated - with a particular device information element or that are associated with all device information elements. - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - Information describing the development. - [in,out] Unique identifier for the interface class. - Zero-based index of the member. - [in,out] Information describing the device interface. - - SetupDiEnumDeviceInterfaces returns TRUE if the function completed without error. - If the function completed with an error, FALSE is returned and the error code for the failure can be retrieved by calling - GetLastError. - - - - - The SetupDiGetClassDevsEx function returns a handle to a device information set that contains requested device information elements - for a local or a remote computer. - - - The caller of SetupDiGetClassDevsEx must delete the returned device information set when it is no longer needed by calling - . - Available in Microsoft Windows 2000 and later versions of Windows. - - [in,out] Unique identifier for the class. - The enumerator. - The parent. - The devs ex flags. - Set the device information belongs to. - Name of the machine. - The reserved. - - If the operation succeeds, SetupDiGetClassDevsEx returns a handle to a device information set that contains all installed - devices that matched the supplied parameters. - If the operation fails, the function returns INVALID_HANDLE_VALUE. To get extended error information, call - GetLastError. - - - - - The SetupDiGetDeviceInterfaceDetail function returns details about a device interface. - - - The interface detail returned by this function consists of a device path that can be passed to Win32 functions such as - CreateFile. - Do not attempt to parse the device path symbolic name. The device path can be reused across system starts. - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - [in,out] Information describing the device interface. - [in,out] Information describing the device interface detail. - Size of the device interface detail data. - Size of the required. - [in,out] Information describing the device information. - - SetupDiGetDeviceInterfaceDetail returns TRUE if the function completed without error. - If the function completed with an error, FALSE is returned and the error code for the failure can be retrieved by calling - GetLastError. - - - - - The SetupDiGetDeviceRegistryProperty function retrieves a specified Plug and Play device property. - - Available in Microsoft Windows 2000 and later versions of Windows. - Set the device information belongs to. - [in,out] Information describing the device information. - The property. - [out] Type of the property register data. - Buffer for property data. - Size of the property buffer. - Size of the required. - - SetupDiGetDeviceRegistryProperty returns TRUE if the call was successful. - Otherwise, it returns FALSE and the logged error can be retrieved by making a call to GetLastError. - SetupDiGetDeviceRegistryProperty returns the ERROR_INVALID_DATA error code if the requested property does not exist for a - device or if the property data is not valid. - - - - The FindFirstFileEx function does not query the short file name, improving overall enumeration speed. -   - - The data is returned in a structure, - and cAlternateFileName member is always a NULL string. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - - - Uses a larger buffer for directory queries, which can increase performance of the find operation. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - DefaultFileBufferSize = 4096; Default type buffer size used for reading and writing files. - - - DefaultFileEncoding = Encoding.UTF8; Default type of Encoding used for reading and writing files. - - - MaxDirectoryLength = 255 - - - MaxPath = 260 - The specified path, file name, or both exceed the system-defined maximum length. - For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters. - - - - MaxPathUnicode = 32000 - - - When an exception is raised, bit shifting is needed to prevent: "System.OverflowException: Arithmetic operation resulted in an overflow." - - - The BackupRead function can be used to back up a file or directory, including the security information. - The function reads data associated with a specified file or directory into a buffer, - which can then be written to the backup medium using the WriteFile function. - - - This function is not intended for use in backing up files encrypted under the Encrypted File System. - Use ReadEncryptedFileRaw for that purpose. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The buffer. - Number of bytes to reads. - [out] Number of bytes reads. - true to abort. - true to process security. - [out] The context. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero, indicating that an I/O error occurred. To get extended error information, - call GetLastError. - - - - The BackupSeek function seeks forward in a data stream initially accessed by using the or - function. - The function reads data associated with a specified file or directory into a buffer, which can then be written to the backup - medium using the WriteFile function. - - - Applications use the BackupSeek function to skip portions of a data stream that cause errors. - This function does not seek across stream headers. For example, this function cannot be used to skip the stream name. - If an application attempts to seek past the end of a substream, the function fails, the lpdwLowByteSeeked and - lpdwHighByteSeeked parameters - indicate the actual number of bytes the function seeks, and the file position is placed at the start of the next stream - header. -   - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The low bytes to seek. - The high bytes to seek. - [out] The lpdw low bytes seeked. - [out] The lpdw high bytes seeked. - [out] The context. - - If the function could seek the requested amount, the function returns a nonzero value. - If the function could not seek the requested amount, the function returns zero. To get extended error information, call - GetLastError. - - - - The BackupWrite function can be used to restore a file or directory that was backed up using . - Use the ReadFile function to get a stream of data from the backup medium, then use BackupWrite to write the data to the - specified file or directory. -   - - - This function is not intended for use in restoring files encrypted under the Encrypted File System. Use WriteEncryptedFileRaw - for that purpose. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The buffer. - Number of bytes to writes. - [out] Number of bytes writtens. - true to abort. - true to process security. - [out] The context. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero, indicating that an I/O error occurred. To get extended error information, - call GetLastError. - - - - Check is the current handle is not null, not closed and not invalid. - The current handle to check. - will throw an , will not raise this exception.. - on success, otherwise. - - - - Check is the current handle is not null, not closed and not invalid. - The current handle to check. - The result of Marshal.GetLastWin32Error() - will throw an , will not raise this exception.. - on success, otherwise. - - - - - Controls whether the system will handle the specified types of serious errors or whether the process will handle them. - - - Because the error mode is set for the entire process, you must ensure that multi-threaded applications do not set different error- - mode attributes. Doing so can lead to inconsistent error handling. - - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - The mode. - The return value is the previous state of the error-mode bit attributes. - - - - Controls whether the system will handle the specified types of serious errors or whether the calling thread will handle them. - - - Because the error mode is set for the entire process, you must ensure that multi-threaded applications do not set different error- - mode attributes. Doing so can lead to inconsistent error handling. - - Minimum supported client: Windows 7 [desktop apps only]. - Minimum supported server: Windows Server 2008 R2 [desktop apps only]. - The new mode. - [out] The old mode. - The return value is the previous state of the error-mode bit attributes. - - - Retrieves the full path and file name of the specified file or directory. - If the function fails for any other reason, the return value is zero. To get extended error information, call GetLastError. - The GetFullPathName function is not recommended for multithreaded applications or shared library code. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the full path and file name of the specified file or directory as a transacted operation. - If the function fails for any other reason, the return value is zero. To get extended error information, call GetLastError. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Converts the specified path to its long form. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Converts the specified path to its long form as a transacted operation. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Retrieves the short path form of the specified path. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Represents a wrapper class for a handle used by the SetupDiGetClassDevs/SetupDiDestroyDeviceInfoList Win32 API functions. - - - Initializes a new instance of the class. - - - Contains the basic information for a file. Used for file handles. - - Specifying -1 for , , or - indicates that operations on the current handle should not affect the given field. - (I.e, specifying -1 for will leave the unaffected by writes performed - on the current handle.) - - - - The time the file was created in format, - which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). - - - - The time the file was last accessed in format. - - - The time the file was last written to in format. - - - The time the file was changed in format. - - - The file attributes. - If this is set to 0 in a structure passed to SetFileInformationByHandle then none of the attributes are changed. - - - Contains information that the GetFileInformationByHandle function retrieves. - - - The file attributes. - - - A structure that specifies when a file or directory is created. - - - A structure. For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - - - - A structure. For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - - - The serial number of the volume that contains a file. - - - The high-order part of the file size. - - - The low-order part of the file size. - - - The number of links to this file. For the FAT file system this member is always 1. For the NTFS file system, it can be more than 1. - - - The high-order part of a unique identifier that is associated with a file. - - - The low-order part of a unique identifier that is associated with a file. - - - Controls whether the system will handle the specified types of serious errors or whether the process will handle them. - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups. - One of the values. - - - Contains information about files in the specified directory. Used for directory handles. Use only when calling GetFileInformationByHandleEx. - - The number of files that are returned for each call to GetFileInformationByHandleEx depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle will resume the enumeration operation after the last file is returned. - - - - The offset for the next FILE_ID_BOTH_DIR_INFO structure that is returned. Contains zero (0) if no other entries follow this one. - - - The byte offset of the file within the parent directory. This member is undefined for file systems, such as NTFS, - in which the position of a file within the parent directory is not fixed and can be changed at any time to maintain sort order. - - - - The time that the file was created. - - - The time that the file was last accessed. - - - The time that the file was last written to. - - - The time that the file was last changed. - - - The absolute new end-of-file position as a byte offset from the start of the file to the end of the file. - Because this value is zero-based, it actually refers to the first free byte in the file. - In other words, EndOfFile is the offset to the byte that immediately follows the last valid byte in the file. - - - - The number of bytes that are allocated for the file. This value is usually a multiple of the sector or cluster size of the underlying physical device. - - - The file attributes. - - - The length of the file name. - - - The size of the extended attributes for the file. - - - The length of ShortName. - - - The short 8.3 file naming convention (for example, "FILENAME.TXT") name of the file. - - - The file ID. - - - The first character of the file name string. This is followed in memory by the remainder of the string. - - - Represents the number of 100-nanosecond intervals since January 1, 1601. This structure is a 64-bit value. - - - Converts a value to long. - - - Converts a value to long. - - - Determines whether the specified Object is equal to the current Object. - Another object to compare to. - if the specified Object is equal to the current Object; otherwise, . - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Implements the operator == - A. - B. - The result of the operator. - - - Implements the operator != - A. - B. - The result of the operator. - - - An SP_DEVINFO_DATA structure defines a device instance that is a member of a device information set. - - - The size, in bytes, of the SP_DEVINFO_DATA structure. - - - The GUID of the device's setup class. - - - An opaque handle to the device instance (also known as a handle to the devnode). - - - Reserved. For internal use only. - - - An SP_DEVICE_INTERFACE_DATA structure defines a device interface in a device information set. - - - The size, in bytes, of the SP_DEVICE_INTERFACE_DATA structure. - - - The GUID for the class to which the device interface belongs. - - - Can be one or more of the following: SPINT_ACTIVE (1), SPINT_DEFAULT (2), SPINT_REMOVED (3). - - - Reserved. Do not use. - - - An SP_DEVICE_INTERFACE_DETAIL_DATA structure contains the path for a device interface. - - - The size, in bytes, of the SP_DEVICE_INTERFACE_DETAIL_DATA structure. - - - The device interface path. This path can be passed to Win32 functions such as CreateFile. - - - WIN32_FILE_ATTRIBUTE_DATA structure contains attribute information for a file or directory. The GetFileAttributesEx function uses this structure. - - Not all file systems can record creation and last access time, and not all file systems record them in the same manner. - For example, on the FAT file system, create time has a resolution of 10 milliseconds, write time has a resolution of 2 seconds, - and access time has a resolution of 1 day. On the NTFS file system, access time has a resolution of 1 hour. - For more information, see File Times. - - - - The file attributes of a file. - - - A structure that specifies when a file or directory was created. - If the underlying file system does not support creation time, this member is zero. - - - A structure. - For a file, the structure specifies when the file was last read from, written to, or for executable files, run. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last access time, this member is zero. - On the FAT file system, the specified date for both files and directories is correct, but the time of day is always set to midnight. - - - - A structure. - For a file, the structure specifies when the file was last written to, truncated, or overwritten, for example, when WriteFile or SetEndOfFile are used. - The date and time are not updated when file attributes or security descriptors are changed. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last write time, this member is zero. - - - - The high-order DWORD of the file size. This member does not have a meaning for directories. - This value is zero unless the file size is greater than MAXDWORD. - The size of the file is equal to (nFileSizeHigh * (MAXDWORD+1)) + nFileSizeLow. - - - - The low-order DWORD of the file size. This member does not have a meaning for directories. - - - The file size. - - - Contains information about the file that is found by the FindFirstFile, FindFirstFileEx, or FindNextFile function. - - If a file has a long file name, the complete name appears in the cFileName member, and the 8.3 format truncated version of the name appears - in the cAlternateFileName member. Otherwise, cAlternateFileName is empty. If the FindFirstFileEx function was called with a value of FindExInfoBasic - in the fInfoLevelId parameter, the cAlternateFileName member will always contain a string value. This remains true for all subsequent calls to the - FindNextFile function. As an alternative method of retrieving the 8.3 format version of a file name, you can use the GetShortPathName function. - For more information about file names, see File Names, Paths, and Namespaces. - - - Not all file systems can record creation and last access times, and not all file systems record them in the same manner. - For example, on the FAT file system, create time has a resolution of 10 milliseconds, write time has a resolution of 2 seconds, - and access time has a resolution of 1 day. The NTFS file system delays updates to the last access time for a file by up to 1 hour - after the last access. For more information, see File Times. - - - - The file attributes of a file. - - - A structure that specifies when a file or directory was created. - If the underlying file system does not support creation time, this member is zero. - - - A structure. - For a file, the structure specifies when the file was last read from, written to, or for executable files, run. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last access time, this member is zero. - On the FAT file system, the specified date for both files and directories is correct, but the time of day is always set to midnight. - - - - A structure. - For a file, the structure specifies when the file was last written to, truncated, or overwritten, for example, when WriteFile or SetEndOfFile are used. - The date and time are not updated when file attributes or security descriptors are changed. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last write time, this member is zero. - - - - The high-order DWORD of the file size. This member does not have a meaning for directories. - This value is zero unless the file size is greater than MAXDWORD. - The size of the file is equal to (nFileSizeHigh * (MAXDWORD+1)) + nFileSizeLow. - - - - The low-order DWORD of the file size. This member does not have a meaning for directories. - - - If the dwFileAttributes member includes the FILE_ATTRIBUTE_REPARSE_POINT attribute, this member specifies the reparse point tag. - Otherwise, this value is undefined and should not be used. - - - - Reserved for future use. - - - The name of the file. - - - An alternative name for the file. This name is in the classic 8.3 file name format. - - - Contains stream data. - - - Type of stream data. - - - Attributes of data to facilitate cross-operating system transfer. - - - Size of data, in bytes. - - - Length of the name of the alternative data stream, in bytes. - - - Defines, redefines, or deletes MS-DOS device names. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Deletes a drive letter or mounted folder. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the name of a volume on a computer. FindFirstVolume is used to begin scanning the volumes of a computer. - - If the function succeeds, the return value is a search handle used in a subsequent call to the FindNextVolume and FindVolumeClose functions. - If the function fails to find any volumes, the return value is the INVALID_HANDLE_VALUE error code. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the name of a mounted folder on the specified volume. FindFirstVolumeMountPoint is used to begin scanning the mounted folders on a volume. - - If the function succeeds, the return value is a search handle used in a subsequent call to the FindNextVolumeMountPoint and FindVolumeMountPointClose functions. - If the function fails to find a mounted folder on the volume, the return value is the INVALID_HANDLE_VALUE error code. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Continues a volume search started by a call to the FindFirstVolume function. FindNextVolume finds one volume per call. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Continues a mounted folder search started by a call to the FindFirstVolumeMountPoint function. FindNextVolumeMountPoint finds one mounted folder per call. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. If no more mounted folders can be found, the GetLastError function returns the ERROR_NO_MORE_FILES error code. - In that case, close the search with the FindVolumeMountPointClose function. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Closes the specified volume search handle. - - SetLastError is set to . - Minimum supported client: Windows XP [desktop apps only]. Minimum supported server: Windows Server 2003 [desktop apps only]. - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Closes the specified mounted folder search handle. - - SetLastError is set to . - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive. - To determine whether a drive is a USB-type drive, call and specify the - SPDRP_REMOVAL_POLICY property. - - - SMB does not support volume management functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Full pathname of the root file. - - The return value specifies the type of drive, see . - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Retrieves a bitmask representing the currently available disk drives. - - - SMB does not support volume management functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is a bitmask representing the currently available disk drives. - Bit position 0 (the least-significant bit) is drive A, bit position 1 is drive B, bit position 2 is drive C, and so on. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves information about the file system and volume associated with the specified root directory. - - If all the requested information is retrieved, the return value is nonzero. - If not all the requested information is retrieved, the return value is zero. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - "lpRootPathName" must end with a trailing backslash. - - - Retrieves information about the file system and volume associated with the specified file. - - If all the requested information is retrieved, the return value is nonzero. - If not all the requested information is retrieved, the return value is zero. To get extended error information, call GetLastError. - - To retrieve the current compression state of a file or directory, use FSCTL_GET_COMPRESSION. - SMB does not support volume management functions. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Retrieves a volume GUID path for the volume that is associated with the specified volume mount point (drive letter, volume GUID path, or mounted folder). - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Use GetVolumeNameForVolumeMountPoint to obtain a volume GUID path for use with functions such as SetVolumeMountPoint and FindFirstVolumeMountPoint that require a volume GUID path as an input parameter. - SMB does not support volume management functions. - Mount points aren't supported by ReFS volumes. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the volume mount point where the specified path is mounted. - - If a specified path is passed, GetVolumePathName returns the path to the volume mount point, which means that it returns the - root of the volume where the end point of the specified path is located. - For example, assume that you have volume D mounted at C:\Mnt\Ddrive and volume E mounted at "C:\Mnt\Ddrive\Mnt\Edrive". Also - assume that you have a file with the path "E:\Dir\Subdir\MyFile". - If you pass "C:\Mnt\Ddrive\Mnt\Edrive\Dir\Subdir\MyFile" to GetVolumePathName, it returns the path "C:\Mnt\Ddrive\Mnt\Edrive\". - If a network share is specified, GetVolumePathName returns the shortest path for which GetDriveType returns DRIVE_REMOTE, - which means that the path is validated as a remote drive that exists, which the current user can access. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves a list of drive letters and mounted folder paths for the specified volume. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Sets the label of a file system volume. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - "lpRootPathName" must end with a trailing backslash. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Associates a volume with a drive letter or a directory on another volume. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves information about MS-DOS device names. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is the number of TCHARs stored into the buffer pointed to by lpTargetPath. If the - function fails, the return value is zero. To get extended error information, call GetLastError. If the buffer is too small, the - function fails and the last error code is ERROR_INSUFFICIENT_BUFFER. - - - - Indicates the format of a path passed to a method. - - At some point in code you know the full path of file system objects, e.g.: "C:\Windows". - For example, Directory.EnumerateFileSystemEntries() will return all files and directories from a given path. - Most likely, some processing will happen on the results of the enum. The file or directory may be passed - on to another function. Whenever a file path is required, some performance can be gained. -   - A path like: "C:\Windows" or "\\server\share" is considered a full path for a directory because it is rooted and has a drive/unc path. - If the method supports it, and will skip GetFullPath() - calls for path resolving of the object, while also avoiding path validation and checks. - Using (default) will always call GetFullPath() and perform path validation and checks. -   - When working in a loop with thousands of files, will give the best performance. - - - - The format of the path is automatically detected by the method and internally converted to an extended length path. - It can be either a standard (short) full path, an extended length (unicode) full path or a relative path. - Example relative path: "Windows". - - - - The path is a full path in either normal or extended length (UNICODE) format. - Internally it will be converted to an extended length (UNICODE) path. - Using this option has a very slight performance advantage compared to using . - Example full path: "C:\Windows" or "\\server\share". - - - - The path is an extended length path. No additional processing will be done on the path, and it will be used as is. - Using this option has a slight performance advantage compared to using . - Example long full path: "\\?\C:\Windows" or "\\?\UNC\server\share". - - - - The exception that is thrown when an attempt to create a directory or file that already exists was made. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The requested operation could not be completed because the device was not ready. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the directory is read-only. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the directory was not empty. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the file is read-only. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - Provides static methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of objects. - This class cannot be inherited. - - - - [AlphaFS] Calculates the hash/checksum for the given . - The name of the file. - One of the values. - - - [AlphaFS] Calculates the hash/checksum for the given . - The name of the file. - One of the values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - The name of the file. - One of the values. - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - The name of the file. - One of the values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - One of the values. - The name of the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The file being backed up is not decrypted; it is backed up in its encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to export encrypted files. See - . - - - To backup an encrypted file call one of the - overloads and specify the file to backup - along with the destination stream of the backup data. - - - This function is intended for the backup of only encrypted files; see for backup - of unencrypted files. - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - - - - [AlphaFS] Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The file being backed up is not decrypted; it is backed up in its encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to export encrypted files. See - . - - - To backup an encrypted file call one of the - overloads and specify the file to backup - along with the destination stream of the backup data. - - - This function is intended for the backup of only encrypted files; see for backup - of unencrypted files. - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - The path format of the parameter. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - The path format of the parameter. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - If set to a hidden file will be overwritten on import. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - If set to a hidden file will be overwritten on import. - The path format of the parameter. - - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The path to the file to enumerate streams of. - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The path to the file to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The transaction. - The path to the file to enumerate streams of. - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The transaction. - The path to the file to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file or directory. - The transaction. - The path to the file or directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file or directory. - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The name of the file. - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The transaction. - The name of the file. - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - - Several Exceptions possible. - - - Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only for files, not directories. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only for files, not directories. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, - and only for files, not directories. - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, - and only for files, not directories. - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - - - Establish a hard link between an existing file and a new file. This function - is only supported on the NTFS file system, and only for files, not directories. - - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - A path that describes a file to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - A path that describes a file to compress. - - - [AlphaFS] Compresses a file using NTFS compression. - The transaction. - A path that describes a file to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - The transaction. - A path that describes a file to compress. - - - [AlphaFS] Decompresses an NTFS compressed file. - A path that describes a file to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed file. - A path that describes a file to decompress. - - - [AlphaFS] Decompresses an NTFS compressed file. - The transaction. - A path that describes a file to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed file. - The transaction. - A path that describes a file to decompress. - - - Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - overrides the read only of the file. - - Indicates the format of the path parameter(s). - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - overrides the read only of the file. - - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - The transaction. - - The name of the file to be deleted. Wildcard characters are not supported. - - - - - - - - [AlphaFS] Deletes the specified file. - The transaction. - The name of the file to be deleted. Wildcard characters are not supported. - overrides the read only of the file. - Indicates the format of the path parameter(s). - If the file to be deleted does not exist, no exception is thrown. - - - - - - - [AlphaFS] Deletes the specified file. - The transaction. - The name of the file to be deleted. Wildcard characters are not supported. - overrides the read only of the file. - If the file to be deleted does not exist, no exception is thrown. - - - - - - - Deletes a Non-/Transacted file. - If the file to be deleted does not exist, no exception is thrown. - - - - - The transaction. - The name of the file to be deleted. - overrides the read only of the file. - Indicates the format of the path parameter(s). - - - Decrypts a file that was encrypted by the current account using the Encrypt method. - A path that describes a file to decrypt. - - - [AlphaFS] Decrypts a file that was encrypted by the current account using the Encrypt method. - A path that describes a file to decrypt. - Indicates the format of the path parameter(s). - - - Encrypts a file so that only the account used to encrypt the file can decrypt it. - A path that describes a file to encrypt. - - - [AlphaFS] Encrypts a file so that only the account used to encrypt the file can decrypt it. - A path that describes a file to encrypt. - Indicates the format of the path parameter(s). - - - Decrypts/encrypts a file or directory so that only the account used to encrypt the file can decrypt it. - - Specifies that is a file or directory. - A path that describes a file to encrypt. - encrypt, decrypt. - Indicates the format of the path parameter(s). - - - Creates or opens a file for writing UTF-8 encoded text. - The file to be opened for writing. - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing UTF-8 encoded text. - The file to be opened for writing. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing encoded text. - The file to be opened for writing. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing UTF-8 encoded text. - The transaction. - The file to be opened for writing. - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing encoded text. - The transaction. - The file to be opened for writing. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - Creates or opens a file for writing encoded text. - The transaction. - The file to be opened for writing. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A that writes to the specified file using NativeMethods.DefaultFileBufferSize encoding. - - - Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory or an existing file. - - - Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory or an existing file. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - - - - - - - - Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Determine the Copy or Move action. - - - Copy/move a Non-/Transacted file or directory including its children to a new location, or can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with the status of the Copy or Move action. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless - contains . - This Move method works across disk volumes, and it does not throw an exception if the - source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into - that directory, you get an IOException. - - - - - - - - - Specifies that and are a file or directory. - The transaction. - The source directory path. - The destination directory path. - if original Timestamps must be preserved, otherwise. This parameter is ignored for move operations. - that specify how the file is to be copied. This parameter can be . - Flags that specify how the file or directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied/moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - The file to check. - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The file to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - - Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - - - Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not - exist, this method creates a file, writes the specified lines to the file, and then closes - the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. - Therefore, the value of the path parameter must contain existing directories. - - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - - The lines to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - - - Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - The character to use. - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - The character to use. - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The file to write to. - The lines to write to the file. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - The file to write to. - The string array to write to the file. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The lines to write to the file. - The character to use. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - The character to use. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The file to write to. - The lines to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The lines to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - The character to use. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Creates a new file, writes the specified string to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The file to write to. - The string to write to the file. - - - Creates a new file, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - - - [AlphaFS] Creates a new file, writes the specified string to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The file to write to. - The string to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The file to write to. - The string to write to the file. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file as part of a transaction, write the contents to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - - - [AlphaFS] Creates a new file as part of a transaction, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - - - [AlphaFS] Creates a new file as part of a transaction, write the contents to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file as part of a transaction, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - - - Creates/appends a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - for file Append, for file Write. - to a line terminator, to ommit the line terminator. - Indicates the format of the path parameter(s). - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or to a new - file if the specified file does not exist. - - The path to the file to append to. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - The character to use. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - Creates or overwrites a file in the specified path. - The path and name of the file to create. - A that provides read/write access to the file specified in . - - - Creates or overwrites the specified file. - The name of the file. - The number of bytes buffered for reads and writes to the file. - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The path and name of the file to create. - Indicates the format of the path parameter(s). - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The name of the file. - The number of bytes buffered for reads and writes to the file. - Indicates the format of the path parameter(s). - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - One of the values that describes how to create or overwrite the - file. - - Indicates the format of the path parameter(s). - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - One of the values that describes how to create or overwrite the - file. - - - One of the values that determines the access control and audit - security for the file. - - Indicates the format of the path parameter(s). - - A new file with the specified buffer size, file options, and file security. - - - - Creates or overwrites a file in the specified path. - The transaction. - The path and name of the file to create. - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The transaction. - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - A with the specified buffer size that provides read/write access - to the file specified in . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The transaction. - The path and name of the file to create. - Indicates the format of the path parameter(s). - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - Indicates the format of the path parameter(s). - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - Indicates the format of the path parameter(s). - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - Indicates the format of the path parameter(s). - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The transaction. - The name of the file. - The additional advanced options to create a file. - - A instance that determines the access control and audit security for the file. - - The option gives you more precise control over how you want to create a file. - - The allow you additionally specify to default read/write capability - just write, bypassing any cache. - - - The option controls how you would like to share created file with other requesters. - - Indicates the format of the parameter. - The number of bytes buffered for reads and writes to the file. - A that provides read/write access to the file specified in path. - - - Creates or opens a file, directory or I/O device. - A that provides read/write access to the file or directory specified by . - - To obtain a directory handle using CreateFile, specify the FILE_FLAG_BACKUP_SEMANTICS flag as part of dwFlagsAndAttributes. - The most commonly used I/O devices are as follows: file, file stream, directory, physical disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - - - - The transaction. - The path and name of the file or directory to create. - One of the values that describes how to create or overwrite the file or directory. - A instance that determines the access control and audit security for the file or directory. - A constant that determines how to open or create the file or directory. - A constant that determines the access rights to use when creating access and audit rules for the file or directory. - A constant that determines how the file or directory will be shared by processes. - . - Indicates the format of the parameter. - - - Determines whether the specified file exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between the time you call the Exists method and perform another operation on the file, such as Delete. - - The file to check. - - Returns if the caller has the required permissions and - contains the name of an existing file; otherwise, - - - - - [AlphaFS] Determines whether the specified file exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, this method merely checks - if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between the time you call the Exists method and perform another operation on the file, such - as Delete. - - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions and - contains the name of an existing file; otherwise, - - - - - - [AlphaFS] Determines whether the specified file exists. - - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between - the time you call the Exists method and perform another operation on the file, such - as Delete. - - The transaction. - The file to check. - - Returns if the caller has the required permissions - and contains the name of an existing file; otherwise, - - - - - - [AlphaFS] Determines whether the specified file exists. - - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between - the time you call the Exists method and perform another operation on the file, such - as Delete. - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions - and contains the name of an existing file; otherwise, - - - - - Determines whether the specified file or directory exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the parameter before checking whether - the directory exists. - The Exists method returns if any error occurs while trying to determine if the specified file - exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - - a failing or missing disk, or if the caller does not have permission to read the file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in between - the time you call the Exists method and perform another operation on the file, such as Delete. - - Specifies that is a file or directory. - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions - and contains the name of an existing file or directory; otherwise, - - - - Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - - - Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a file containing a object that describes the file's access control list (ACL) information. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets an object for a particular file or directory. - An object that encapsulates the access control rules for the file or directory described by the parameter. - - - - Generic type parameter. - Specifies that is a file or directory. - The path to a file/directory containing a / object that describes the file's/directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - Gets the of the file on the path. - The path to the file. - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The path to the file. - Indicates the format of the path parameter(s). - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The transaction. - The path to the file. - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The transaction. - The path to the file. - Indicates the format of the path parameter(s). - The of the file on the path. - - - Gets the or of the specified file or directory. - The or of the specified file or directory. - - - Generic type parameter. - The transaction. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - - - Calls NativeMethods.GetFileAttributesEx to retrieve WIN32_FILE_ATTRIBUTE_DATA. - Note that classes should use -1 as the uninitialized state for dataInitialized when relying on this method. - - No path (null, empty string) checking or normalization is performed. - . - . - [in,out]. - . - . - 0 on success, otherwise a Win32 error code. - - - Gets the creation date and time of the specified file. - The file for which to obtain creation date and time information. - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The transaction. - The file for which to obtain creation date and time information. - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The transaction. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - The transaction. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - The transaction. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) or local time, of the specified file or directory. - - The transaction. - The file or directory for which to obtain creation date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file or directory. Depending on - this value is expressed in UTC- or local time. - - - - Gets the date and time that the specified file was last accessed. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) or local time, that the specified file or directory was last - accessed. - - The transaction. - The file or directory for which to obtain access date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file or directory was last accessed. - Depending on this value is expressed in UTC- or local time. - - - - Gets the date and time that the specified file was last written to. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The transaction. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The transaction. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The transaction. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The transaction. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) or local time, that the specified file or directory was last - written to. - - The transaction. - The file or directory for which to obtain write date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file or directory was last written to. - Depending on this value is expressed in UTC- or local time. - - - - Opens a on the specified path with read/write access. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A opened in the specified mode and path, with read/write access and not shared. - - - Opens a on the specified path, with the specified mode and access. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - An unshared that provides access to the specified file, with the specified mode and access. - - - Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - A on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - - - [AlphaFS] Opens a on the specified path with read/write access. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - Indicates the format of the path parameter(s). - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] Opens a on the specified path, with the specified mode and access. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - Indicates the format of the path parameter(s). - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - The extended attributes. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path with read/write access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] (Transacted) Opens a on the specified path with read/write access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - Indicates the format of the path parameter(s). - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] (Transacted) Opens a on the specified path, with the specified mode and access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path, with the specified mode and access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - Indicates the format of the path parameter(s). - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Indicates the format of the path parameter(s). - A on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - The extended attributes. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access, the specified sharing option and additional options specified. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Advanced options for this file. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - The security. - Indicates the format of the path parameter(s). - - A instance on the specified path, having the specified mode with - read, write, or read/write access and the specified sharing option. - - - - Opens a on the specified path, having the specified mode with read, write, or read/write access, the specified sharing option and additional options specified. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - A value specifying the type of access other threads have to the file. - Advanced options for this file. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - The security. - Indicates the format of the path parameter(s). - - A instance on the specified path, having the specified mode with - read, write, or read/write access and the specified sharing option. - - - - Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The file to open for reading. - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The transaction. - The file to open for reading. - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - All lines of the file. - - - Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Opens a file, read all lines of the file with the specified encoding, and then close the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - An IEnumerable string containing all lines of the file. - - - Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - All lines of the file. - - - Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Open a file, read all lines of the file with the specified encoding, and then close the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Reads the lines of a file. - The file to read. - All the lines of the file, or the lines that are the result of a query. - - - Read the lines of a file that has a specified encoding. - The file to read. - The encoding that is applied to the contents of the file. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The file to read. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The transaction. - The file to read. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The transaction. - The file to read. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - Reads the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - - Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a backup of - the replaced file. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - - - Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a backup of - the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - - - - [AlphaFS] Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a - backup of the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - Indicates the format of the path parameter(s). - - - Replaces the contents of a specified file with the contents of another file, deleting - the original file, and creating a backup of the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - - - - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - - - - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a / object to the specified file or directory. - Use either or , not both. - - - - A file/directory to add or remove access control list (ACL) entries from. This parameter This parameter may be . - A to add or remove access control list (ACL) entries from. This parameter This parameter may be . - A / object that describes an ACL entry to apply to the file/directory described by the / parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Sets the specified of the file or directory on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The path to the file or directory. - A bitwise combination of the enumeration values. - Sets the specified of the file or directory on the specified path. - - - [AlphaFS] Sets the specified of the file or directory on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The path to the file or directory. - A bitwise combination of the enumeration values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the specified of the file on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The transaction. - The path to the file. - A bitwise combination of the enumeration values. - - - [AlphaFS] Sets the specified of the file on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The transaction. - The path to the file. - A bitwise combination of the enumeration values. - Indicates the format of the path parameter(s). - - - Sets the attributes for a Non-/Transacted file/directory. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using the SetAttributes method. - - - Specifies that is a file or directory. - The transaction. - The name of the file or directory whose attributes are to be set. - - The attributes to set for the file or directory. Note that all other values override . - - - does not throw an Exception when the file system object does not exist. - - Indicates the format of the path parameter(s). - - - Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Set the date and time, in coordinated universal time (UTC), that the file or directory was created and/or last accessed and/or written to. - - - Specifies that is a file or directory. - The transaction. - The file or directory for which to set the date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - - Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already exists, it is - overwritten. - - The file to write to. - The bytes to write to the file. - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The transaction. - The file to write to. - The bytes to write to the file. - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The transaction. - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - Creates a new file as part of a transaction, writes the specified byte array to - the file, and then closes the file. If the target file already exists, it is overwritten. - - - The transaction. - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The file for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - An open handle to the file or directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The transaction. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The transaction. - The file for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - An open handle to the file or directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - Use either or , not both. - - - - Specifies that is a file or directory. - The transaction. - An open handle to the file or directory from which to retrieve information. - The file or directory for which to obtain creation date and time information. - gets the Coordinated Universal Time (UTC), gets the local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file. - - If the file is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size - of the specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value - obtained is the sparse size of the specified file. - - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file. - - If the file is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size - of the specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value - obtained is the sparse size of the specified file. - - The name of the file. - The actual number of bytes of disk storage used to store the specified file. - - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file as part of a transaction. If the file - is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size of the - specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value obtained is - the sparse size of the specified file. - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file as part of a transaction. If the file - is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size of the - specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value obtained is - the sparse size of the specified file. - - The transaction. - The name of the file. - The actual number of bytes of disk storage used to store the specified file. - - - Retrieves the actual number of bytes of disk storage used to store a - specified file as part of a transaction. If the file is located on a volume that supports compression and the file is compressed, - the value obtained is the compressed size of the specified file. If the file is located on a volume that supports sparse files and - the file is a sparse file, the value obtained is the sparse size of the specified file. - - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the encryption status of the specified file. - The name of the file. - Indicates the format of the path parameter(s). - The of the specified . - - - [AlphaFS] Retrieves the encryption status of the specified file. - The name of the file. - The of the specified . - - - Retrieves the encryption status of the specified file. - The name of the file. - Indicates the format of the path parameter(s). - The of the specified . - - - [AlphaFS] Retrieves file information for the specified . - A connected to the open file from which to retrieve the information. - A object containing the requested information. - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The path to the file or directory. - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The transaction. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The transaction. - The path to the file or directory. - - - Gets a FileSystemEntryInfo from a Non-/Transacted directory/file. - The instance of the file or directory, or null on Exception when is true. - BasicSearch and LargeCache are used by default, if possible. - - - Specifies that is a file or directory. - The transaction. - The path to the file or directory. - - true suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The path to the reparse point. - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The path to the file. - Indicates the format of the path parameter(s). - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The path to the file. - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The to the file. - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The transaction. - The path to the file. - Indicates the format of the path parameter(s). - The number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The transaction. - The path to the file. - The number of bytes of disk storage used to store the specified file. - - - Retrieves the file size, in bytes to store a specified file. - Use either or , not both. - The transaction. - The to the file. - The path to the file. - Indicates the format of the path parameter(s). - The number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The transaction. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The transaction. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - - - Transfer the date and time stamps for the specified files and directories. - - This method does not change last access time for the source file. - This method uses BackupSemantics flag to get Timestamp changed for directories. - - Specifies that and are a file or directory. - The transaction. - The source path. - The destination path. - Indicates the format of the path parameter(s). - - - Opens an existing file for reading. - The file to be opened for reading. - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The transaction. - The file to be opened for reading. - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The transaction. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - Opens an existing UTF-8 encoded text file for reading. - The file to be opened for reading. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The file to be opened for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The file to be opened for reading. - The applied to the contents of the file. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The transaction. - The file to be opened for reading. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The transaction. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The transaction. - The file to be opened for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The transaction. - The file to be opened for reading. - The applied to the contents of the file. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - Opens an existing file or creates a new file for writing. - The file to be opened for writing. - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The file to be opened for writing. - Indicates the format of the path parameter(s). - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The transaction. - The file to be opened for writing. - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The transaction. - The file to be opened for writing. - Indicates the format of the path parameter(s). - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The file path to open. - Indicates the format of the path parameter(s). - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. This method is simpler to use then BackupFileStream to read only file's data stream. - The file path to open. - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The transaction. - The file path to open. - Indicates the format of the path parameter(s). - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The transaction. - The file path to open. - A on the specified path, having the read-only mode and sharing options. - - - Provides access to information of a device, on a local or remote host. - - - Initializes a DeviceInfo class. - - - Initializes a DeviceInfo class. - The DNS or NetBIOS name of the remote server. refers to the local host. - - - Enumerates all available devices on the local host. - One of the devices. - instances of type from the local host. - - - Represents the value of the base container identifier (ID) .The Windows Plug and Play (PnP) manager assigns this value to the device node (devnode). - - - Represents the name of the device setup class that a device instance belongs to. - - - Represents the of the device setup class that a device instance belongs to. - - - Represents the list of compatible identifiers for a device instance. - - - Represents a description of a device instance. - - - The device interface path. - - - Represents the registry entry name of the driver key for a device instance. - - - Represents the name of the enumerator for a device instance. - - - Represents the friendly name of a device instance. - - - Represents the list of hardware identifiers for a device instance. - - - The host name that was passed to the class constructor. - - - Gets the instance Id of the device. - - - Represents the bus-specific physical location of a device instance. - - - Represents the location of a device instance in the device tree. - - - Represents the name of the manufacturer of a device instance. - - - Encapsulates the physical device location information provided by a device's firmware to Windows. - - - Represents the name of the service that is installed for a device instance. - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, - the total amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - This class cannot be inherited. - - - - Initializes a DiskSpaceInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share - This is a Lazyloading object; call to populate all properties first before accessing. - - - Initializes a DiskSpaceInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share - gets both size- and disk cluster information. Get only disk cluster information, Get only size information. - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Refreshes the state of the object. - - - Initializes all properties to 0. - - - Returns the drive name. - A string that represents this object. - - - Indicates the amount of available free space on a drive, formatted as percentage. - - - Indicates the amount of available free space on a drive, formatted as a unit size. - - - Returns the Clusters size. - - - Gets the name of a drive. - The name of the drive. - This property is the name assigned to the drive, such as C:\ or E:\ - - - The total number of bytes on a disk that are available to the user who is associated with the calling thread, formatted as a unit size. - - - Indicates the amount of used space on a drive, formatted as percentage. - - - Indicates the amount of used space on a drive, formatted as a unit size. - - - The total number of free bytes on a disk that are available to the user who is associated with the calling thread. - - - The total number of bytes on a disk that are available to the user who is associated with the calling thread. - - - The total number of free bytes on a disk. - - - The number of bytes per sector. - - - The total number of free clusters on the disk that are available to the user who is associated with the calling thread. - - - The number of sectors per cluster. - - - The total number of clusters on the disk that are available to the user who is associated with the calling thread. - If per-user disk quotas are in use, this value may be less than the total number of clusters on the disk. - - - - Provides access to information on a local or remote drive. - - This class models a drive and provides methods and properties to query for drive information. - Use DriveInfo to determine what drives are available, and what type of drives they are. - You can also query to determine the capacity and available free space on the drive. - - - - Provides access to information on the specified drive. - - - - A valid drive path or drive letter. - This can be either uppercase or lowercase, - 'a' to 'z' or a network share in the format: \\server\share - - - - Indicates the amount of available free space on a drive. - The amount of free space available on the drive, in bytes. - This property indicates the amount of free space available on the drive. Note that this number may be different from the number because this property takes into account disk quotas. - - - Gets the name of the file system, such as NTFS or FAT32. - Use DriveFormat to determine what formatting a drive uses. - - - Gets the drive type. - One of the values. - - The DriveType property indicates whether a drive is any of: CDRom, Fixed, Unknown, Network, NoRootDirectory, - Ram, Removable, or Unknown. Values are listed in the enumeration. - - - - Gets a value indicating whether a drive is ready. - if the drive is ready; otherwise, . - - IsReady indicates whether a drive is ready. For example, it indicates whether a CD is in a CD drive or whether - a removable storage device is ready for read/write operations. If you do not test whether a drive is ready, and - it is not ready, querying the drive using DriveInfo will raise an IOException. - - Do not rely on IsReady() to avoid catching exceptions from other members such as TotalSize, TotalFreeSpace, and DriveFormat. - Between the time that your code checks IsReady and then accesses one of the other properties - (even if the access occurs immediately after the check), a drive may have been disconnected or a disk may have been removed. - - - - Gets the name of the drive. - The name of the drive. - This property is the name assigned to the drive, such as C:\ or E:\ - - - Gets the root directory of a drive. - A DirectoryInfo object that contains the root directory of the drive. - - - Gets the total amount of free space available on a drive. - The total free space available on a drive, in bytes. - This property indicates the total amount of free space available on the drive, not just what is available to the current user. - - - Gets the total size of storage space on a drive. - The total size of the drive, in bytes. - This property indicates the total size of the drive in bytes, not just what is available to the current user. - - - Gets or sets the volume label of a drive. - The volume label. - - The label length is determined by the operating system. For example, NTFS allows a volume label - to be up to 32 characters long. Note that is a valid VolumeLabel. - - - - [AlphaFS] Returns the instance. - - - [AlphaFS] The MS-DOS device name. - - - [AlphaFS] Indicates if this drive is a SUBST.EXE / DefineDosDevice drive mapping. - - - [AlphaFS] Indicates if this drive is a UNC path. - Only retrieve this information if we're dealing with a real network share mapping: http://alphafs.codeplex.com/discussions/316583 - - - [AlphaFS] Determines whether the specified volume name is a defined volume on the current computer. - - - [AlphaFS] Contains information about a file-system volume. - A VolumeInfo object that contains file-system volume information of the drive. - - - Retrieves the drive names of all logical drives on a computer. - An array of type that represents the logical drives on a computer. - - - Returns a drive name as a string. - The name of the drive. - This method returns the Name property. - - - [AlphaFS] Enumerates the drive names of all logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - An IEnumerable of type that represents - the logical drives on a computer. - - - - [AlphaFS] Gets the first available drive letter on the local system. - A drive letter as . When no drive letters are available, an exception is thrown. - The letters "A" and "B" are reserved for floppy drives and will never be returned by this function. - - - Gets an available drive letter on the local system. - When get the last available drive letter. When gets the first available drive letter. - A drive letter as . When no drive letters are available, an exception is thrown. - The letters "A" and "B" are reserved for floppy drives and will never be returned by this function. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - - - Used by CopyFileXxx and MoveFileXxx. The function should return one of the following values. - - - PROGRESS_CONTINUE - Continue the copy operation. - - - - PROGRESS_CANCEL - Cancel the copy operation and delete the destination file. - - - - PROGRESS_STOP - Stop the copy operation. It can be restarted at a later time. - - - - PROGRESS_QUIET - Continue the copy operation, but stop invoking to report progress. - - - - [AlphaFS] Directory enumeration options, flags that specify how a directory is to be enumerated. - - - None (do not use). - - - Enumerate files only. - - - Enumerate directories only. - - - Enumerate files and directories. - - - Return full path as long full path (Unicode format), only valid when return type is . - - - Skip reparse points during directory enumeration. - - - Suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - - - Specifies whether to search the current directory, or the current directory and all subdirectories. - - - Enumerates the directory without querying the short file name, improving overall enumeration speed. - This option is enabled by default if supported. This value is not supported until Windows Server 2008 R2 and Windows 7. - - - Enumerates the directory using a larger buffer for directory queries, which can increase performance of the find operation. - This option is enabled by default if supported. This value is not supported until Windows Server 2008 R2 and Windows 7. - - - System-Defined Device Interface Classes - http://msdn.microsoft.com/en-us/library/windows/hardware/ff541389%28v=vs.85%29.aspx - - - The BUS1394_CLASS_GUID device interface class is defined for 1394 bus devices. - - - The GUID_61883_CLASS device interface class is defined for devices in the 61883 device setup class. - - - The GUID_DEVICE_APPLICATIONLAUNCH_BUTTON device interface class is defined for Advanced Configuration and Power Interface (ACPI) application start buttons. - - - The GUID_DEVICE_BATTERY device interface class is defined for battery devices. - - - The GUID_DEVICE_LID device interface class is defined for Advanced Configuration and Power Interface (ACPI) lid devices. - - - The GUID_DEVICE_MEMORY device interface class is defined for Advanced Configuration and Power Interface (ACPI) memory devices. - - - The GUID_DEVICE_MESSAGE_INDICATOR device interface class is defined for Advanced Configuration and Power Interface (ACPI) message indicator devices. - - - The GUID_DEVICE_PROCESSOR device interface class is defined for Advanced Configuration and Power Interface (ACPI) processor devices. - - - The GUID_DEVICE_SYS_BUTTON device interface classis defined for Advanced Configuration and Power Interface (ACPI) system power button devices. - - - The GUID_DEVICE_THERMAL_ZONE device interface class is defined for Advanced Configuration and Power Interface (ACPI) thermal zone devices. - - - The GUID_BTHPORT_DEVICE_INTERFACE device interface class is defined for Bluetooth radios. - - - The GUID_DEVINTERFACE_BRIGHTNESS device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and support brightness control of monitor child devices. - - - The GUID_DEVINTERFACE_DISPLAY_ADAPTER device interface class is defined for display views that are supported by display adapters. - - - The GUID_DEVINTERFACE_I2C device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and perform I2C transactions with monitor child devices. - - - The GUID_DEVINTERFACE_IMAGE device interface class is defined for WIA devices and Still Image (STI) devices, including digital cameras and scanners. - - - The GUID_DEVINTERFACE_MONITOR device interface class is defined for monitor devices. - - - The GUID_DEVINTERFACE_OPM device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and support output protection management (OPM) for monitor child devices. - - - The GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL device interface class is defined for child devices of display devices. - - - The GUID_DISPLAY_DEVICE_ARRIVAL device interface class is defined for display adapters. - - - The GUID_DEVINTERFACE_HID device interface class is defined for HID collections. - - - The GUID_DEVINTERFACE_KEYBOARD device interface class is defined for keyboard devices. - - - The GUID_DEVINTERFACE_MOUSE device interface class is defined for mouse devices. - - - The GUID_DEVINTERFACE_MODEM device interface class is defined for modem devices. - - - The GUID_DEVINTERFACE_NET device interface class is defined for network devices. - - - The GUID_DEVINTERFACE_COMPORT device interface class is defined for COM ports. - - - The GUID_DEVINTERFACE_PARALLEL device interface class is defined for parallel ports that support an IEEE 1284-compatible hardware interface. - - - The GUID_DEVINTERFACE_PARCLASS device interface class is defined for devices that are attached to a parallel port. - - - The GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR device interface class is defined for Plug and Play (PnP) serial ports. - - - The GUID_DEVINTERFACE_CDCHANGER device interface class is defined for CD-ROM changer devices. - - - The GUID_DEVINTERFACE_CDROM device interface class is defined for CD-ROM storage devices. - - - The GUID_DEVINTERFACE_DISK device interface class is defined for hard disk storage devices. - - - The GUID_DEVINTERFACE_FLOPPY device interface class is defined for floppy disk storage devices. - - - The GUID_DEVINTERFACE_MEDIUMCHANGER device interface class is defined for medium changer devices. - - - The GUID_DEVINTERFACE_PARTITION device interface class is defined for partition devices. - - - The GUID_DEVINTERFACE_STORAGEPORT device interface class is defined for storage port devices. - - - The GUID_DEVINTERFACE_TAPE device interface class is defined for tape storage devices. - - - The GUID_DEVINTERFACE_VOLUME device interface class is defined for volume devices. - - - The GUID_DEVINTERFACE_WRITEONCEDISK device interface class is defined for write-once disk devices. - - - The GUID_DEVINTERFACE_USB_DEVICE device interface class is defined for USB devices that are attached to a USB hub. - - - The GUID_DEVINTERFACE_USB_HOST_CONTROLLER device interface class is defined for USB host controller devices. - - - The GUID_DEVINTERFACE_USB_HUB device interface class is defined for USB hub devices. - - - Defines the controllable aspects of the Volume.DefineDosDevice() method. - - - DDD_EXACT_MATCH_ON_REMOVE - Default. - - - - DDD_RAW_TARGET_PATH - Uses the targetPath string as is. Otherwise, it is converted from an MS-DOS path to a path. - - - - DDD_REMOVE_DEFINITION - Removes the specified definition for the specified device. - To determine which definition to remove, the function walks the list of mappings for the device, looking for a match of targetPath against a prefix of each mapping associated with this device. - The first mapping that matches is the one removed, and then the function returns. - If targetPath is null or a pointer to a null string, the function will remove the first mapping associated with the device and pop the most recent one pushed.If there is nothing left to pop, the device name will be removed. - If this value is not specified, the string pointed to by the targetPath parameter will become the new mapping for this device. - - - - DDD_EXACT_MATCH_ON_REMOVE - If this value is specified along with , the function will use an exact match to determine which mapping to remove. - Use this value to ensure that you do not delete something that you did not define. - - - - DDD_NO_BROADCAST_SYSTEM - Do not broadcast the WM_SETTINGCHANGE message. - By default, this message is broadcast to notify the shell and applications of the change. - - - - Determines the format to convert a path to using - - - (FileNameNormalized / VolumeNameDos) Return the normalized drive name. This is the default. - - - Return the path with a volume GUID path instead of the drive name. - - - Return the path with the volume device path. - - - Return the path with no drive information. - - - Return the opened file name (not normalized). - - - Enumeration specifying the different reparse point tags. - - Reparse tags, with the exception of IO_REPARSE_TAG_SYMLINK, are processed on the server and are not processed by a client after transmission over the wire. - Clients should treat associated reparse data as opaque data. - - - - The entry is not a reparse point. - - - IO_REPARSE_APPXSTREAM - - - IO_REPARSE_TAG_CSV - - - IO_REPARSE_TAG_DRIVER_EXTENDER - Used by Home server drive extender. - - - - IO_REPARSE_TAG_DEDUP - - - IO_REPARSE_TAG_DFS - Used by the DFS filter. - - - - IO_REPARSE_TAG_DFSR - Used by the DFS filter. - - - - IO_REPARSE_TAG_FILTER_MANAGER - Used by filter manager test harness. - - - - IO_REPARSE_TAG_HSM - (Obsolete) Used by legacy Hierarchical Storage Manager Product. - - - - IO_REPARSE_TAG_HSM2 - (Obsolete) Used by legacy Hierarchical Storage Manager Product. - - - - IO_REPARSE_TAG_NFS - NFS symlinks, Windows 8 / SMB3 and later. - - - - IO_REPARSE_TAG_MOUNT_POINT - Used for mount point support. - - - - IO_REPARSE_TAG_SIS - Used by single-instance storage (SIS) filter driver. - - - - IO_REPARSE_TAG_SYMLINK - Used for symbolic link support. - - - - IO_REPARSE_TAG_WIM - - - WIN32_STREAM_ID Attributes of data to facilitate cross-operating system transfer. - - - STREAM_NORMAL_ATTRIBUTE - This backup stream has no special attributes. - - - - STREAM_MODIFIED_WHEN_READ - Attribute set if the stream contains data that is modified when read. - Allows the backup application to know that verification of data will fail. - - - - STREAM_CONTAINS_SECURITY - The backup stream contains security information. - This attribute applies only to backup stream of type . - - - - Reserved. - - - STREAM_SPARSE_ATTRIBUTE - The backup stream is part of a sparse file stream. - This attribute applies only to backup stream of type , , and . - - - - The type of the data contained in the backup stream. - - - This indicates an error. - - - BACKUP_DATA - Standard data. This corresponds to the NTFS $DATA stream type on the default (unnamed) data stream. - - - - BACKUP_EA_DATA - Extended attribute data. This corresponds to the NTFS $EA stream type. - - - - BACKUP_SECURITY_DATA - Security descriptor data. - - - - BACKUP_ALTERNATE_DATA - Alternative data streams. This corresponds to the NTFS $DATA stream type on a named data stream. - - - - BACKUP_LINK - Hard link information. This corresponds to the NTFS $FILE_NAME stream type. - - - - BACKUP_PROPERTY_DATA - Property data. - - - - BACKUP_OBJECT_ID - Objects identifiers. This corresponds to the NTFS $OBJECT_ID stream type. - - - - BACKUP_REPARSE_DATA - Reparse points. This corresponds to the NTFS $REPARSE_POINT stream type. - - - - BACKUP_SPARSE_BLOCK - Sparse file. This corresponds to the NTFS $DATA stream type for a sparse file. - - - - BACKUP_TXFS_DATA - Transactional NTFS (TxF) data stream. - - Windows Server 2003 and Windows XP: This value is not supported. - - - Flags that specify how a file or directory is to be copied. - - - No CopyOptions used, this allows overwriting the file. - - - COPY_FILE_FAIL_IF_EXISTS - The copy operation fails immediately if the target file already exists. - - - - COPY_FILE_RESTARTABLE - - Progress of the copy is tracked in the target file in case the copy fails. The failed copy can be restarted at a later time by specifying the same values - forexisting file name and new file name as those used in the call that failed. This can significantly slow down the copy operation as the new file may be - flushed multiple times during the copy operation. - - - - - COPY_FILE_OPEN_SOURCE_FOR_WRITE - The file is copied and the original file is opened for write access. - - - - COPY_FILE_ALLOW_DECRYPTED_DESTINATION - An attempt to copy an encrypted file will succeed even if the destination copy cannot be encrypted. - - - - COPY_FILE_COPY_SYMLINK - If the source file is a symbolic link, the destination file is also a symbolic link pointing to the same file that the source symbolic link is pointing to. - - - - COPY_FILE_NO_BUFFERING - The copy operation is performed using unbuffered I/O, bypassing system I/O cache resources. Recommended for very large file transfers. - - - - Used by CopyFileXxx and MoveFileXxx. The reason that was called. - - - CALLBACK_CHUNK_FINISHED - Another part of the data file was copied. - - - - CALLBACK_STREAM_SWITCH - Another stream was created and is about to be copied. This is the callback reason given when the callback routine is first invoked. - - - - Provides static methods to retrieve device resource information from a local or remote host. - - - Enumerates all available devices on the local host. - instances of type from the local host. - One of the devices. - - - Enumerates all available devices of type on the local or remote host. - instances of type for the specified . - The name of the local or remote host on which the device resides. refers to the local host. - One of the devices. - - - Enumerates all available devices on the local or remote host. - - - Get information about the target of a mount point or symbolic link on an NTFS file system. - - - Sets the NTFS compression state of a file or directory on a volume whose file system supports per-file and per-directory compression. - Specifies that is a file or directory. - The transaction. - A path that describes a folder or file to compress or decompress. - = compress, = decompress - Indicates the format of the path parameter(s). - - - Builds a DeviceInfo Data structure. - An initialized NativeMethods.SP_DEVINFO_DATA instance. - - - Builds a Device Interface Data structure. - An initialized NativeMethods.SP_DEVICE_INTERFACE_DATA instance. - - - Builds a Device Interface Detail Data structure. - An initialized NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA instance. - - - Repeatedly invokes InvokeIoControl with the specified input until enough memory has been allocated. - - - The provides access to data associated with a specific file or directory, including security information and alternative data streams, for backup and restore operations. - This class uses the BackupRead, - BackupSeek and - BackupWrite functions from the Win32 API to provide access to the file or directory. - - - - Initializes a new instance of the class with the specified path and creation mode. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - The file will be opened for exclusive access for both reading and writing. - - - Initializes a new instance of the class with the specified path, creation mode and access rights. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - The file will be opened for exclusive access. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, and additional file attributes. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, additional file attributes, access control and audit security. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - A constant that determines the access control and audit security for the file. This parameter This parameter may be . - - - Initializes a new instance of the class with the specified path and creation mode. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - The file will be opened for exclusive access for both reading and writing. - - - Initializes a new instance of the class with the specified path, creation mode and access rights. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - The file will be opened for exclusive access. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, and additional file attributes. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, additional file attributes, access control and audit security. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - A constant that determines the access control and audit security for the file. This parameter This parameter may be . - - - Initializes a new instance of the class for the specified file handle, with the specified read/write permission. - A file handle for the file that this object will encapsulate. - A constant that gets the and properties of the object. - - - When overridden in a derived class, gets the length in bytes of the stream. - This method always throws an exception. - - - - When overridden in a derived class, gets or sets the position within the current stream. - This method always throws an exception. - - - - When overridden in a derived class, sets the position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - The new position within the current stream. - This stream does not support seeking using this method, and calling this method will always throw . See for an alternative way of seeking forward. - - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - This method is not supported by the class, and calling it will always generate a . - - - - Gets a value indicating whether the current stream supports reading. - if the stream supports reading, otherwise. - - - Gets a value indicating whether the current stream supports seeking. - This method always returns . - - - Gets a value indicating whether the current stream supports writing. - if the stream supports writing, otherwise. - - - Gets a object that represents the operating system file handle for the file that the current object encapsulates. - A object that represents the operating system file handle for the file that - the current object encapsulates. - - - Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - This method will not backup the access-control list (ACL) data for the file or directory. - - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between - and ( + - 1) replaced by the bytes read from the - current source. - - - The zero-based byte offset in at which to begin storing the data read from the current stream. - - The maximum number of bytes to be read from the current stream. - - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not - currently available, or zero (0) if the end of the stream has been reached. - - - - - - - - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values - between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - Indicates whether the function will backup the access-control list (ACL) data for the file or directory. - - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not - currently available, or zero (0) if the end of the stream has been reached. - - - - - - - - - Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - - Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - - - - - - This method will not process the access-control list (ACL) data for the file or directory. - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - Specifies whether the function will restore the access-control list (ACL) data for the file or directory. - If this is you need to specify and access when - opening the file or directory handle. If the handle does not have those access rights, the operating system denies - access to the ACL data, and ACL data restoration will not occur. - - - - - - - - Clears all buffers for this stream and causes any buffered data to be written to the underlying device. - - - Skips ahead the specified number of bytes from the current stream. - This method represents the Win32 API implementation of BackupSeek. - - Applications use the method to skip portions of a data stream that cause errors. This function does not - seek across stream headers. For example, this function cannot be used to skip the stream name. If an application - attempts to seek past the end of a substream, the function fails, the return value indicates the actual number of bytes - the function seeks, and the file position is placed at the start of the next stream header. - - - The number of bytes to skip. - The number of bytes actually skipped. - - - Gets a object that encapsulates the access control list (ACL) entries for the file described by the current object. - - - A object that encapsulates the access control list (ACL) entries for the file described by the current - object. - - - - Applies access control list (ACL) entries described by a object to the file described by the current object. - A object that describes an ACL entry to apply to the current file. - - - Prevents other processes from changing the while permitting read access. - The beginning of the range to lock. The value of this parameter must be equal to or greater than zero (0). - The range to be locked. - - - - - Allows access by other processes to all or part of a file that was previously locked. - The beginning of the range to unlock. - The range to be unlocked. - - - - - - Reads a stream header from the current . - The stream header read from the current , or if the end-of-file - was reached before the required number of bytes of a header could be read. - - The stream must be positioned at where an actual header starts for the returned object to represent valid - information. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - to release both managed and unmanaged resources; to release only unmanaged resources. - - - Releases unmanaged resources and performs other cleanup operations before the is reclaimed by garbage collection. - - - Represents the encryption status of the specified file. - - - The file can be encrypted. - - - The file is encrypted. - - - The file is a system file. System files cannot be encrypted. - - - The file is a root directory. Root directories cannot be encrypted. - - - The file is a system directory. System directories cannot be encrypted. - - - The encryption status is unknown. The file may be encrypted. - - - The file system does not support file encryption. - - - Reserved for future use. - - - The file is a read-only file. - - - Contains information that the GetFileInformationByHandle function retrieves. - - - Gets the file attributes. - The file attributes. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - Gets the time this entry was last accessed. - For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - If the underlying file system does not support the last access time, this member is zero (0). - - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - If the underlying file system does not support the last access time, this member is zero (0). - - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - If the underlying file system does not support the last access time, this member is zero (0). - - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - If the underlying file system does not support the last access time, this member is zero (0). - - The time, in coordinated universal time (UTC), this entry was last modified. - - - Gets the serial number of the volume that contains a file. - The serial number of the volume that contains a file. - - - Gets the size of the file. - The size of the file. - - - Gets the number of links to this file. For the FAT file system this member is always 1. For the NTFS file system, it can be more than 1. - The number of links to this file. - - - - Gets the unique identifier associated with the file. The identifier and the volume serial number uniquely identify a - file on a single computer. To determine whether two open handles represent the same file, combine the identifier - and the volume serial number for each file and compare them. - - The unique identifier of the file. - - - Contains information about files in the specified directory. Used for directory handles. - - - The number of bytes that are allocated for the file. This value is usually a multiple of the sector or cluster size of the underlying physical device. - - - Gets the time this entry was changed. - The time this entry was changed. - - - Gets the time, in coordinated universal time (UTC), this entry was changed. - The time, in coordinated universal time (UTC), this entry was changed. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - The size of the extended attributes for the file. - - - The absolute new end-of-file position as a byte offset from the start of the file to the end of the file. - Because this value is zero-based, it actually refers to the first free byte in the file. In other words, EndOfFile is the offset to - the byte that immediately follows the last valid byte in the file. - - - - The file attributes. - - - The file ID. - - - The byte offset of the file within the parent directory. This member is undefined for file systems, such as NTFS, - in which the position of a file within the parent directory is not fixed and can be changed at any time to maintain sort order. - - - - The name of the file. - - - Gets the time this entry was last accessed. - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - The time, in coordinated universal time (UTC), this entry was last modified. - - - The short 8.3 file naming convention (for example, FILENAME.TXT) name of the file. - - - Provides properties and instance methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of objects. This class cannot be inherited. - - - [AlphaFS] Calculates the hash/checksum. - One of the values. - - - Refreshes the state of the EntryInfo instance. - - - [AlphaFS] Returns an enumerable collection of instances for the file. - An enumerable collection of instances for the file. - - - [AlphaFS] Decompresses an NTFS compressed file. - - - [AlphaFS] Compresses a file using NTFS compression. - - - Returns the path as a string. - The path. - - - Applies access control list (ACL) entries described by a FileSecurity object to the file described by the current FileInfo object. - - The SetAccessControl method applies access control list (ACL) entries to the current file that represents the noninherited ACL - list. Use the SetAccessControl method whenever you need to add or remove ACL entries from a file. - - A object that describes an access control list (ACL) entry to apply to the current file. - - - Applies access control list (ACL) entries described by a FileSecurity object to the file described by the current FileInfo object. - - The SetAccessControl method applies access control list (ACL) entries to the current file that represents the noninherited ACL - list. Use the SetAccessControl method whenever you need to add or remove ACL entries from a file. - - A object that describes an access control list (ACL) entry to apply to the current file. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - - - Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise, . - - - [AlphaFS] Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise, . - Indicates the format of the path parameter(s). - - - Refreshes the state of the object. - - - Creates a write-only . - A write-only unshared object for a new or existing file. - - - Creates a with NativeMethods.DefaultFileEncoding encoding that reads from an existing text file. - A new with NativeMethods.DefaultFileEncoding encoding. - - - [AlphaFS] Creates a with that reads from an existing text file. - A new with the specified . - The applied to the contents of the file. - - - Creates a read-only . - A new read-only object. - This method returns a read-only object with the mode set to Read. - - - Opens a file in the specified mode. - A file opened in the specified mode, with read/write access and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - - - Opens a file in the specified mode with read, write, or read/write access. - A object opened in the specified mode and access, and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A constant specifying whether to open the file with Read, Write, or ReadWrite file access. - - - Opens a file in the specified mode with read, write, or read/write access and the specified sharing option. - A object opened with the specified mode, access, and sharing options. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A constant specifying whether to open the file with Read, Write, or ReadWrite file access. - A constant specifying the type of access other objects have to this file. - - - [AlphaFS] Opens a file in the specified mode with read, write, or read/write access. - A object opened in the specified mode and access, and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - - - [AlphaFS] Opens a file in the specified mode with read, write, or read/write access and the specified sharing option. - A object opened with the specified mode, access, and sharing options. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - A constant specifying the type of access other objects have to this file. - - - Gets a object that encapsulates the access control list (ACL) entries for the file described by the current object. - A FileSecurity object that encapsulates the access control rules for the current file. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for the file described by the current FileInfo object. - object that encapsulates the specified type of access control list (ACL) entries for the file described by the current FileInfo object. - One of the values that specifies which group of access control entries to retrieve. - - - Encrypts a file so that only the account used to encrypt the file can decrypt it. - - - Permanently deletes a file. - If the file does not exist, this method does nothing. - - - - - [AlphaFS] Permanently deletes a file. - If the file does not exist, this method does nothing. - overrides the read only of the file. - - - Decrypts a file that was encrypted by the current account using the Encrypt method. - - - Creates a instance that writes a new text file. - A new - - - Creates a file. - A new file. - - - Copies an existing file to a new file, disallowing the overwriting of an existing file. - A new instance with a fully qualified path. - - Use this method to prevent overwriting of an existing file by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - - - Copies an existing file to a new file, allowing the overwriting of an existing file. - - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - to allow an existing file to be overwritten; otherwise, . - - - [AlphaFS] Copies an existing file to a new file, disallowing the overwriting of an existing file. - - Use this method to prevent overwriting of an existing file by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file. - - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - to allow an existing file to be overwritten; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a specified file to a new location, providing the option to specify a new file name. - - Use this method to prevent overwriting of an existing file by default. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to prevent overwriting of an existing file by default. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move an existing file to a new file, allowing the overwriting of an existing file. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Copy or Move action. - A full path string to the destination directory - if original Timestamps must be preserved, otherwise. - This parameter can be . Use to specify how the file is to be copied. - This parameter can be . Use that specify how the file is to be moved. - This parameter can be . A callback function that is called each time another portion of the file has been copied. - This parameter can be . The argument to be passed to the callback function. - [out] Returns the retrieved long full path. - Indicates the format of the path parameter(s). - - - - - - - - - Creates a that appends text to the file represented by this instance of the . - A new - - - Creates a that appends text to the file represented by this instance of the . - The character to use. - A new - - - Initializes a new instance of the class, which acts as a wrapper for a file path. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The transaction. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The transaction. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - Gets an instance of the parent directory. - A object representing the parent directory of this file. - To get the parent directory as a string, use the DirectoryName property. - - - - Gets a string representing the directory's full path. - A string representing the directory's full path. - - To get the parent directory as a DirectoryInfo object, use the Directory property. - When first called, FileInfo calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - - - - - Gets a value indicating whether the file exists. - if the file exists; otherwise, . - - The property returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - - - Gets or sets a value that determines if the current file is read only. - if the current file is read only; otherwise, . - - Use the IsReadOnly property to quickly determine or change whether the current file is read only. - When first called, FileInfo calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - - - - - - Gets the size, in bytes, of the current file. - The size of the current file in bytes. - - The value of the Length property is pre-cached - To get the latest value, call the Refresh method. - - - - - - Gets the name of the file. - The name of the file. - - The name of the file includes the file extension. - When first called, calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - The name of the file includes the file extension. - - - - Specifies how the operating system should open a file. - - - If you pass , the set of attributes is unspecified. explicitly sets no attributes. - - - The file is read only. Applications can read the file, but cannot write to or delete it. - Equals 1 - - - The file is hidden. Do not include it in an ordinary directory listing. - Equals 2 - - - The file is part of or used exclusively by an operating system. - Equals 4 - - - The handle that identifies a directory. - Equals 16 - - - The file should be archived. Applications use this attribute to mark files for backup or removal. - Equals 32 - - - The file should be archived. Applications use this attribute to mark files for backup or removal. - Equals 64 - - - The file does not have other attributes set. This attribute is valid only if used alone. - Equals 128 - - - The file is being used for temporary storage. - Equals 256 - - - A file that is a sparse file. - Equals 512 - - - A file or directory that has an associated reparse point, or a file that is a symbolic link. - Equals 1024 - - - A file or directory that is compressed. For a file, all of the data in the file is compressed. For a directory, compression is the default for newly created files and subdirectories. - Equals 2048 - - - The data of a file is not immediately available. This attribute indicates that file data is physically moved to offline storage. This attribute is used by Remote Storage, the hierarchical storage management software. Applications should not arbitrarily change this attribute. - Equals 4096 - - - The file or directory is not to be indexed by the content indexing service. - Equals 8192 - - - The file or directory is encrypted. For a file, this means that all data in the file is encrypted. For a directory, this means that encryption is the default for newly created files and subdirectories. - Equals 16384 - - - The directory or user data stream is configured with integrity (only supported on ReFS volumes). It is not included in an ordinary directory listing. The integrity setting persists with the file if it's renamed. If a file is copied the destination file will have integrity set if either the source file or destination directory have integrity set. - This flag is not supported until Windows Server 2012. - - - The user data stream not to be read by the background data integrity scanner (AKA scrubber). When set on a directory it only provides inheritance. This flag is only supported on Storage Spaces and ReFS volumes. It is not included in an ordinary directory listing. - This flag is not supported until Windows Server 2012. - - - ... - - - The file data is requested, but it should continue to be located in remote storage. It should not be transported back to local storage. This flag is for use by remote storage systems. - - - Normal reparse point processing will not occur; an attempt to open the reparse point will be made. When a file is opened, a file handle is returned, whether or not the filter that controls the reparse point is operational. See MSDN documentation for more information. - - - Access will occur according to POSIX rules. This includes allowing multiple files with names, differing only in case, for file systems that support that naming. Use care when using this option, because files created with this flag may not be accessible by applications that are written for MS-DOS or 16-bit Windows. - - - The file is being opened or created for a backup or restore operation. The system ensures that the calling process overrides file security checks when the process has SE_BACKUP_NAME and SE_RESTORE_NAME privileges. You must set this flag to obtain a handle to a directory. A directory handle can be passed to some functions instead of a file handle. - - - The file is to be deleted immediately after all of its handles are closed, which includes the specified handle and any other open or duplicated handles. If there are existing open handles to a file, the call fails unless they were all opened with the share mode. Subsequent open requests for the file fail, unless the share mode is specified. - Equals 67108864 - - - Access is intended to be sequential from beginning to end. The system can use this as a hint to optimize file caching. - Equals 134217728 - - - Access is intended to be random. The system can use this as a hint to optimize file caching. - Equals 268435456 - - - There are strict requirements for successfully working with files opened with the flag, for details see the section on "File Buffering" in the online MSDN documentation. - - - The file or device is being opened or created for asynchronous I/O. - Equals 1073741824 - - - Write operations will not go through any intermediate cache, they will go directly to disk. - Equals .NET -2147483648 - - - Class that retrieves file system entries (i.e. files and directories) using Win32 API FindFirst()/FindNext(). - - - Get an enumerator that returns all of the file system objects that match the wildcards that are in any of the directories to be searched. - An instance: FileSystemEntryInfo, DirectoryInfo, FileInfo or string (full path). - - - Gets a specific file system object. - - The return type is based on C# inference. Possible return types are: - - (full path), - ( or ), instance - or null in case an Exception is raised and is . - - - - Gets or sets the ability to return the object as a instance. - returns the object as a instance. - - - Gets or sets the ability to return the full path in long full path format. - returns the full path in long full path format, returns the full path in regular path format. - - - Gets or sets the ability to return the object instance as a . - returns the full path of the object as a - - - Gets the value indicating which to use. - - - Gets or sets the ability to skip on access errors. - suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - - - Gets the file system object type. - - = Return files and directories. - = Return only directories. - = Return only files. - - - - Gets or sets if the path is an absolute or relative path. - Gets a value indicating whether the specified path string contains absolute or relative path information. - - - Gets or sets the initial path to the folder. - The initial path to the file or folder in long path format. - - - Gets or sets the path to the folder. - The path to the file or folder in long path format. - - - Gets or sets a value indicating which to use. - indicates a folder object, indicates a file object. - - - Gets the value indicating which to use. - - - Specifies whether the search should include only the current directory or should include all subdirectories. - to all subdirectories. - - - Search for file system object-name using a pattern. - The path which has wildcard characters, for example, an asterisk () or a question mark (). - - - skips ReparsePoints, will follow ReparsePoints. - - - Get or sets the KernelTransaction instance. - The transaction. - - - Represents information about a file system entry. - This class cannot be inherited. - - - - Initializes a new instance of the class. - The NativeMethods.WIN32_FIND_DATA structure. - - - Gets the 8.3 version of the filename. - the 8.3 version of the filename. - - - Gets the attributes. - The attributes. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - Gets the name of the file. - The name of the file. - - - Gets the size of the file. - The size of the file. - - - The full path of the file system object. - - - Gets a value indicating whether this instance is compressed. - if this instance is compressed; otherwise, . - - It is not possible to change the compression status of a File object by using the SetAttributes method. - Instead, you must actually compress the file using either a compression tool or one of the classes in the namespace. - - - - Gets a value indicating whether this instance is hidden, and thus is not included in an ordinary directory listing. - if this instance is hidden; otherwise, . - - - Gets a value indicating whether this instance represents a directory. - if this instance represents a directory; otherwise, . - - - Gets a value indicating whether this instance is encrypted (EFS). - if this instance is encrypted (EFS); otherwise, . - - For a file, this means that all data in the file is encrypted. - For a directory, this means that encryption is the default for newly created files and directories. - - - - Gets a value indicating whether this instance is a mount point. - if this instance is a mount point; otherwise, . - - - Gets a value indicating whether this instance is offline. The data of the file is not immediately available. - if this instance is offline; otherwise, . - - - Gets a value indicating whether this instance is read-only. - if this instance is read-only; otherwise, . - - - Gets a value indicating whether this instance contains a reparse point, which is a block of user-defined data associated with a file or a directory. - if this instance contains a reparse point; otherwise, . - - - Gets a value indicating whether this instance is a symbolic link. - if this instance is a symbolic link; otherwise, . - - - Gets the time this entry was last accessed. - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - The time, in coordinated universal time (UTC), this entry was last modified. - - - The full path of the file system object in Unicode (LongPath) format. - - - Gets the reparse point tag of this entry. - The reparse point tag of this entry. - - - Gets internal WIN32 FIND Data - - - Returns the of the instance. - The instance as a string. - - - Provides the base class for both and objects. - - - Deletes a file or directory. - - - Refreshes the state of the object. - - FileSystemInfo.Refresh() takes a snapshot of the file from the current file system. - Refresh cannot correct the underlying file system even if the file system returns incorrect or outdated information. - This can happen on platforms such as Windows 98. - Calls must be made to Refresh() before attempting to get the attribute information, or the information will be - outdated. - - - - Returns a string that represents the current object. - - ToString is the major formatting method in the .NET Framework. It converts an object to its string representation so that it is - suitable for display. - - A string that represents this instance. - - - Determines whether the specified Object is equal to the current Object. - Another object to compare to. - if the specified Object is equal to the current Object; otherwise, . - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Implements the operator == - A. - B. - The result of the operator. - - - Implements the operator != - A. - B. - The result of the operator. - - - Refreshes the state of the EntryInfo instance. - - FileSystemInfo.RefreshEntryInfo() takes a snapshot of the file from the current file system. - Refresh cannot correct the underlying file system even if the file system returns incorrect or outdated information. - This can happen on platforms such as Windows 98. - Calls must be made to Refresh() before attempting to get the attribute information, or the information will be outdated. - - - - [AlphaFS] Resets the state of the file system object to uninitialized. - - - Initializes the specified file name. - - - Specifies that is a file or directory. - The transaction. - The full path and name of the file. - Indicates the format of the path parameter(s). - - - - Gets or sets the attributes for the current file or directory. - - - The value of the CreationTime property is pre-cached - To get the latest value, call the Refresh method. - - of the current . - - - - - - - Gets or sets the creation time of the current file or directory. - - The value of the CreationTime property is pre-cached To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions whose values may not be continuously updated by - the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - NTFS-formatted drives may cache file meta-info, such as file creation time, for a short period of time. - This process is known as file tunneling. As a result, it may be necessary to explicitly set the creation time of a file if you are - overwriting or replacing an existing file. - - The creation date and time of the current object. - - - - - - Gets or sets the creation time, in coordinated universal time (UTC), of the current file or directory. - - The value of the CreationTimeUtc property is pre-cached - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - To get the latest value, call the Refresh method. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC). - NTFS-formatted drives may cache file meta-info, such as file creation time, for a short period of time. - This process is known as file tunneling. As a result, it may be necessary to explicitly set the creation time - of a file if you are overwriting or replacing an existing file. - - The creation date and time in UTC format of the current object. - - - - - - - Gets a value indicating whether the file or directory exists. - - - The property returns if any error occurs while trying to determine if the - specified file or directory exists. - This can occur in situations that raise exceptions such as passing a directory- or file name with invalid characters or too - many characters, - a failing or missing disk, or if the caller does not have permission to read the file or directory. - - if the file or directory exists; otherwise, . - - - - Gets the string representing the extension part of the file. - - - The Extension property returns the extension, including the period (.). - For example, for a file c:\NewFile.txt, this property returns ".txt". - - A string containing the extension. - - - - Gets the full path of the directory or file. - - A string containing the full path. - - - Gets or sets the time the current file or directory was last accessed. - - The value of the LastAccessTime property is pre-cached - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The time that the current file or directory was last accessed. - - - - - Gets or sets the time, in coordinated universal time (UTC), that the current file or directory was last accessed. - - The value of the LastAccessTimeUtc property is pre-cached. - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The UTC time that the current file or directory was last accessed. - - - - - Gets or sets the time when the current file or directory was last written to. - - The value of the LastWriteTime property is pre-cached. - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The time the current file was last written. - - - - - Gets or sets the time, in coordinated universal time (UTC), when the current file or directory was last written to. - - The value of the LastWriteTimeUtc property is pre-cached. To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions whose values may not be continuously updated by - the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return 12:00 midnight, January 1, 1601 - A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The UTC time when the current file was last written to. - - - - For files, gets the name of the file. For directories, gets the name of the last directory in the hierarchy if a hierarchy exists. - Otherwise, the Name property gets the name of the directory. - - - For a directory, Name returns only the name of the parent directory, such as Dir, not c:\Dir. - For a subdirectory, Name returns only the name of the subdirectory, such as Sub1, not c:\Dir\Sub1. - For a file, Name returns only the file name and file name extension, such as MyFile.txt, not c:\Dir\Myfile.txt. - - - A string that is the name of the parent directory, the name of the last directory in the hierarchy, - or the name of a file, including the file name extension. - - - - Returns the path as a string. - - - [AlphaFS] Gets the instance of the class. - - - [AlphaFS] The initial "IsDirectory" indicator that was passed to the constructor. - - - The full path of the file system object in Unicode (LongPath) format. - - - [AlphaFS] Represents the KernelTransaction that was passed to the constructor. - - - Represents the fully qualified path of the file or directory. - - Classes derived from can use the FullPath field - to determine the full path of the object being manipulated. - - - - The path originally specified by the user, whether relative or absolute. - - - A bitfield of flags for specifying options for various internal operations that convert paths to full paths. - - - No special options applies. - - - Remove any trailing whitespace from the path. - - - Add a trailing directory separator to the path (if one does not already exist). - - - Remove the trailing directory separator from the path (if one exists). - - - Return full path as long full path (Unicode format). Not valid for . - - - Prevents any exception from being thrown if a filesystem object does not exist. Not valid for . - - - Check that the path contains only valid path-characters. - - - Also check for wildcard (? and *) characters. - - - Do not trim the trailing dot or space. - - - Performs both and checks. - - - Performs operations on String instances that contain file or directory path information. These operations are performed in a cross-platform manner. - - - Determines whether a path includes a file name extension. - if the characters that follow the last directory separator (\\ or /) or volume separator (:) in the path include a period (.) followed by one or more characters; otherwise, . - - The path to search for an extension. The path cannot contain any of the characters defined in . - - - Gets a value indicating whether the specified path string contains absolute or relative path information. - if contains a root; otherwise, . - - The IsPathRooted method returns if the first character is a directory separator character such as - , or if the path starts with a drive letter and colon (). - For example, it returns true for path strings such as "\\MyDir\\MyFile.txt", "C:\\MyDir", or "C:MyDir". - It returns for path strings such as "MyDir". - - This method does not verify that the path or file name exists. - - - The path to test. The path cannot contain any of the characters defined in . - - - [AlphaFS] Gets a value indicating whether the specified path string contains absolute or relative path information. - if contains a root; otherwise, . - - The IsPathRooted method returns true if the first character is a directory separator character such as - , or if the path starts with a drive letter and colon (). - For example, it returns for path strings such as "\\MyDir\\MyFile.txt", "C:\\MyDir", or "C:MyDir". - It returns for path strings such as "MyDir". - - This method does not verify that the path or file name exists. - - - The path to test. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - [AlphaFS] Check if file or folder name has any invalid characters. - - File or folder name. - if name contains any invalid characters. Otherwise - - - Checks that the given path format is supported. - - - A path to the file or directory. - Checks that the path contains only valid path-characters. - . - - - Checks that the path contains only valid path-characters. - - - A path to the file or directory. - also checks for ? and * characters. - When , throws an . - - - Tranlates DosDevicePath, Volume GUID. For example: "\Device\HarddiskVolumeX\path\filename.ext" can translate to: "\path\filename.ext" or: "\\?\Volume{GUID}\path\filename.ext". - A translated dos path. - A DosDevicePath, for example: \Device\HarddiskVolumeX\path\filename.ext. - Alternate path/device text, usually string.Empty or . - - - Check if is a directory- and/or volume-separator character. - if is a separator character. - The character to check. - - If , checks for all separator characters: , - and - If , only checks for: and - If only checks for: - - - - Changes the extension of a path string. - The modified path information. - - The path information to modify. The path cannot contain any of the characters defined in . - The new extension (with or without a leading period). Specify to remove an existing extension from path. - - - Returns the directory information for the specified path string. - - Directory information for , or if denotes a root directory or is - . - Returns if does not contain directory information. - - - The path of a file or directory. - - - [AlphaFS] Returns the directory information for the specified path string. - - Directory information for , or if denotes a root directory or is - . Returns if does not contain directory information. - - - The path of a file or directory. - will check for invalid path characters. - - - [AlphaFS] Returns the directory information for the specified path string without the root information, for example: "C:\Windows\system32" returns: "Windows". - The without the file name part and without the root information (if any), or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - The path. - - - [AlphaFS] Returns the directory information for the specified path string without the root information, for example: "C:\Windows\system32" returns: "Windows". - The without the file name part and without the root information (if any), or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - The transaction. - The path. - - - Returns the extension of the specified path string. - - The extension of the specified path (including the period "."), or null, or . - If is null, this method returns null. - If does not have extension information, - this method returns . - - - - The path string from which to get the extension. The path cannot contain any of the characters defined in . - - - Returns the extension of the specified path string. - - The extension of the specified path (including the period "."), or null, or . - If is null, this method returns null. - If does not have extension information, - this method returns . - - - The path string from which to get the extension. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - Returns the file name and extension of the specified path string. - - The characters after the last directory character in . If the last character of is a - directory or volume separator character, this method returns string.Empty. If path is null, this method returns null. - - - The path string from which to obtain the file name and extension. The path cannot contain any of the characters defined in . - - - [AlphaFS] Returns the file name and extension of the specified path string. - - The characters after the last directory character in . If the last character of is a - directory or volume separator character, this method returns string.Empty. If path is null, this method returns null. - - - The path string from which to obtain the file name and extension. - will check for invalid path characters. - - - Returns the file name of the specified path string without the extension. - The string returned by GetFileName, minus the last period (.) and all characters following it. - - The path of the file. The path cannot contain any of the characters defined in . - - - [AlphaFS] Returns the file name of the specified path string without the extension. - The string returned by GetFileName, minus the last period (.) and all characters following it. - - The path of the file. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - Gets an array containing the characters that are not allowed in file names. - An array containing the characters that are not allowed in file names. - - - Gets an array containing the characters that are not allowed in path names. - An array containing the characters that are not allowed in path names. - - - Gets the root directory information of the specified path. - - Returns the root directory of , such as "C:\", - or if is , - or an empty string if does not contain root directory information. - - - The path from which to obtain root directory information. - - - [AlphaFS] Gets the root directory information of the specified path. - - Returns the root directory of , such as "C:\", - or if is , - or an empty string if does not contain root directory information. - - - The path from which to obtain root directory information. - will check for invalid path characters. - - - [AlphaFS] Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". - - Then handle to a instance. - - - [AlphaFS] Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". - - Then handle to a instance. - The final path, formatted as - - - Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". The string that is returned by this function uses the - syntax. - - Then handle to a instance. - The final path, formatted as - - - Combines an array of strings into a path. - The combined paths. - - - An array of parts of the path. - - - Combines an array of strings into a path. - The combined paths. - - The parameters are not parsed if they have white space. - Therefore, if path2 includes white space (for example, " c:\\ "), - the Combine method appends path2 to path1 instead of returning only path2. - - - - will not check for invalid path characters. - An array of parts of the path. - - - AltDirectorySeparatorChar = '/' Provides a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - DirectorySeparatorChar = '\' Provides a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - PathSeparator = ';' A platform-specific separator character used to separate path strings in environment variables. - - - VolumeSeparatorChar = ':' Provides a platform-specific Volume Separator character. - - - [AlphaFS] AltDirectorySeparatorChar = "/" Provides a platform-specific alternate string used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - [AlphaFS] CurrentDirectoryPrefix = '.' Provides a current directory character. - - - [AlphaFS] CurrentDirectoryPrefix = "." Provides a current directory string. - - - [AlphaFS] DirectorySeparator = "\" Provides a platform-specific string used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - [AlphaFS] ExtensionSeparatorChar = '.' Provides an Extension Separator character. - - - [AlphaFS] ParentDirectoryPrefix = ".." Provides a parent directory string. - - - [AlphaFS] StreamSeparator = ':' Provides a platform-specific Stream-name character. - - - [AlphaFS] StreamSeparator = ':' Provides a platform-specific Stream-name character. - - - [AlphaFS] StreamDataLabel = ':$DATA' Provides a platform-specific Stream :$DATA label. - - - [AlphaFS] StringTerminatorChar = '\0' String Terminator Suffix. - - - [AlphaFS] Characters to trim from the SearchPattern. - - - [AlphaFS] VolumeSeparatorChar = ':' Provides a platform-specific Volume Separator character. - - - [AlphaFS] WildcardStarMatchAll = "*" Provides a match-all-items string. - - - [AlphaFS] WildcardStarMatchAll = '*' Provides a match-all-items character. - - - [AlphaFS] WildcardQuestion = "?" Provides a replace-item string. - - - [AlphaFS] WildcardQuestion = '?' Provides a replace-item string. - - - [AlphaFS] UncPrefix = "\\" Provides standard Windows Path UNC prefix. - - - [AlphaFS] LongPathPrefix = "\\?\" Provides standard Windows Long Path prefix. - - - [AlphaFS] LongPathUncPrefix = "\\?\UNC\" Provides standard Windows Long Path UNC prefix. - - - [AlphaFS] GlobalRootPrefix = "\\?\GLOBALROOT\" Provides standard Windows Volume prefix. - - - [AlphaFS] MsDosNamespacePrefix = "\\.\" Provides standard logical drive prefix. - - - [AlphaFS] SubstitutePrefix = "\??\" Provides a SUBST.EXE Path prefix to a Logical Drive. - - - [AlphaFS] VolumePrefix = "\\?\Volume" Provides standard Windows Volume prefix. - - - [AlphaFS] DevicePrefix = "\Device\" Provides standard Windows Device prefix. - - - [AlphaFS] DosDeviceLanmanPrefix = "\Device\LanmanRedirector\" Provides a MS-Dos Lanman Redirector Path UNC prefix to a network share. - - - [AlphaFS] DosDeviceMupPrefix = "\Device\Mup\" Provides a MS-Dos Mup Redirector Path UNC prefix to a network share. - - - [AlphaFS] DosDeviceUncPrefix = "\??\UNC\" Provides a SUBST.EXE Path UNC prefix to a network share. - - - Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The file or directory for which to obtain absolute path information. - - - Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - [AlphaFS] Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The transaction. - The file or directory for which to obtain absolute path information. - - - [AlphaFS] Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The transaction. - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - Retrieves the absolute path for the specified string. - The fully qualified location of , such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - The transaction. - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - Applies the to - with applied . - - - - - - - [AlphaFS] Adds a trailing character to the string, when absent. - A text string with a trailing character. The function returns when is . - A text string to which the trailing is to be added, when absent. - - - [AlphaFS] Adds a trailing or character to the string, when absent. - A text string with a trailing or character. The function returns when is . - A text string to which the trailing or is to be added, when absent. - If the character will be added instead. - - - [AlphaFS] Removes the trailing character from the string, when present. - A text string where the trailing character has been removed. The function returns when is . - A text string from which the trailing is to be removed, when present. - - - [AlphaFS] Removes the trailing or character from the string, when present. - A text string where the trailing or character has been removed. The function returns when is . - A text string from which the trailing or is to be removed, when present. - If the trailing character will be removed instead. - - - [AlphaFS] Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The path. - - - [AlphaFS] Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The transaction. - The path. - - - [AlphaFS] Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The path. - - - [AlphaFS] Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The transaction. - The path. - - - Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The transaction. - The path. - - - Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The transaction. - The path. - - - [AlphaFS] Gets the connection name of the locally mapped drive. - The server and share as: \\servername\sharename. - - - - - The local path with drive name. - - - [AlphaFS] Gets the network share name from the locally mapped path. - The network share connection name of . - - - - - The local path with drive name. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path, optionally skip invalid path character check. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - will check for invalid path characters. - - - [AlphaFS] Converts a local path to a network share path. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - - - [AlphaFS] Converts a local path to a network share path, optionally returning it in a long path format. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - - - [AlphaFS] Converts a local path to a network share path, optionally returning it in a long path format and the ability to add or remove a trailing backslash. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - adds a trailing character to , when absent. - removes the trailing character from , when present. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path, optionally skip invalid path character check. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - When indicates that is already in regular path format. - will check for invalid path characters. - - - Converts a local path to a network share path. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - adds a trailing character to , when absent. - removes the trailing character from , when present. - - - Makes an extended long path from the specified by prefixing . - The prefixed with a , the minimum required full path is: "C:\". - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - - - The path to the file or directory, this can also be an UNC path. - - - [AlphaFS] Converts the specified existing path to its regular long form. - An existing path to a folder or file. - The regular full path. - - - [AlphaFS] Converts the specified existing path to its regular long form. - The transaction. - An existing path to a folder or file. - The regular full path. - - - [AlphaFS] Gets the regular path from long prefixed one. i.e.: "\\?\C:\Temp\file.txt" to C:\Temp\file.txt" or: "\\?\UNC\Server\share\file.txt" to "\\Server\share\file.txt". - Regular form path string. - This method does not handle paths with volume names, eg. \\?\Volume{GUID}\Folder\file.txt. - The path. - - - [AlphaFS] Retrieves the short path form of the specified path. - A path that has the 8.3 path form. - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short path name. - An existing path to a folder or file. - - - [AlphaFS] Retrieves the short path form of the specified path. - A path that has the 8.3 path form. - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short path name. - The transaction. - An existing path to a folder or file. - - - [AlphaFS] Determines whether the specified path starts with a or . - if the specified path has a long path (UNC) prefix, otherwise. - The path to the file or directory. - - - Makes an extended long path from the specified by prefixing . - The prefixed with a , the minimum required full path is: "C:\". - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - - - The path to the file or directory, this can also be an UNC path. - Options for controlling the full path retrieval. - - - Retrieves the short path form, or the regular long form of the specified . - If is , a path of the 8.3 form otherwise the regular long form. - - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short- or long path name. - - The transaction. - An existing path to a folder or file. - to retrieve the short path form, to retrieve the regular long form from the 8.3 . - - - Gets the regular path from a long path. - - Returns the regular form of a long . - For example: "\\?\C:\Temp\file.txt" to: "C:\Temp\file.txt", or: "\\?\UNC\Server\share\file.txt" to: "\\Server\share\file.txt". - - - MSDN: String.TrimEnd Method notes to Callers: http://msdn.microsoft.com/en-us/library/system.string.trimend%28v=vs.110%29.aspx - - - - The path. - Options for controlling the full path retrieval. - When , throws an . - - - Gets the path as a long full path. - The path as an extended length path. - - The transaction. - Full pathname of the source path to convert. - The path format to use. - Options for controlling the operation. Note that on .NET 3.5 the TrimEnd option has no effect. - - - Returns a random folder name or file name. - A random folder name or file name. - - - Creates a uniquely named, zero-byte temporary file on disk and returns the full path of that file. - The full path of the temporary file. - - - Returns the path of the current user's temporary folder. - The path to the temporary folder, ending with a backslash. - - - [AlphaFS] Returns the path of the current user's temporary folder. - The folder name to append to the temporary folder. - The path to the temporary folder, combined with . - - - Represents a wrapper class for a handle used by the CM_Connect_Machine/CM_Disconnect_Machine Win32 API functions. - - - Initializes a new instance of the class. - - - Represents a wrapper class for a handle used by the FindFirstFile/FindNextFile Win32 API functions. - - - Constructor that prevents a default instance of this class from being created. - - - Constructor that prevents a default instance of this class from being created. - The handle. - true to reliably release the handle during the finalization phase; false to prevent - reliable release (not recommended). - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - Contains Shell32 information about a file. - - - Initializes a Shell32Info instance. - Shell32 is limited to MAX_PATH length. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - - - Initializes a Shell32Info instance. - Shell32 is limited to MAX_PATH length. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - - - Gets an handle to the Shell icon that represents the file. - Icon size or . Can also be combined with and others. - An handle to the Shell icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - - Gets the Shell command association from the registry. - The shell verb. - - Returns the associated file- or protocol-related Shell command from the registry or string.Empty if no association can be - found. - - - - Refreshes the state of the object. - - - Returns the path as a string. - The path. - - - Gets the Shell file or protocol association from the registry. - - - The attributes of the file object. - - - Gets the Shell command association from the registry. - - - Gets the Shell command association from the registry. - - - Gets the Shell DDE association from the registry. - - - Gets the Shell default icon association from the registry. - - - Represents the fully qualified path of the file. - - - Gets the Shell friendly application name association from the registry. - - - Gets the Shell friendly document name association from the registry. - - - Reflects the initialization state of the instance. - - - Gets the Shell "Open With" command association from the registry. - - - Class for CopyMoveResult that contains the results for the Copy or Move action. - - - Create a CopyMoveResult class instance for the Copy or Move action. - Indicates the source file or directory. - Indicates the destination file or directory. - Indicates if the action was canceled. - The error code encountered during the Copy or Move action. - - - The error code encountered during the Copy or Move action. - 0 (zero) indicates success. - - - The error message from the that was encountered during the Copy or Move action. - A message describing the error. - - - When true indicates that the Copy or Move action was canceled. - when the Copy/Move action was canceled. Otherwise . - - - Indicates the source file or directory. - - - Indicates the destination file or directory. - - - The total number of folders copied. - - - The total number of files copied. - - - The total number of bytes copied. - - - Information about the target of a symbolic link or mount point. - - - The print name. - - - The substitute name. - - - Used by MoveFileXxx.Flags that specify how a file or directory is to be moved. - - - No MoveOptions used, this fails when the file name already exists. - - - MOVE_FILE_REPLACE_EXISTSING - If the destination file name already exists, the function replaces its contents with the contents of the source file. - This value cannot be used if lpNewFileName or lpExistingFileName names a directory. - This value cannot be used if either source or destination names a directory. - - - - MOVE_FILE_COPY_ALLOWED - If the file is to be moved to a different volume, the function simulates the move by using the CopyFile and DeleteFile functions. - This value cannot be used with . - - - - MOVE_FILE_DELAY_UNTIL_REBOOT - - The system does not move the file until the operating system is restarted. - The system moves the file immediately after AUTOCHK is executed, but before creating any paging files. - - - Consequently, this parameter enables the function to delete paging files from previous startups. - This value can only be used if the process is in the context of a user who belongs to the administrators group or the LocalSystem account. - - This value cannot be used with . - - - - MOVE_FILE_WRITE_THROUGH - The function does not return until the file has actually been moved on the disk. - - Setting this value guarantees that a move performed as a copy and delete operation is flushed to disk before the function returns. - The flush occurs at the end of the copy operation. - - This value has no effect if is set. - - - - MOVE_FILE_CREATE_HARDLINK - Reserved for future use. - - - - MOVE_FILE_FAIL_IF_NOT_TRACKABLE - The function fails if the source file is a link source, but the file cannot be tracked after the move. - This situation can occur if the destination is a volume formatted with the FAT file system. - - - - The file or directory was not a reparse point. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - Provides access to a file system object, using Shell32. - - - Provides information for the IQueryAssociations interface methods, used by Shell32. - - - None. - - - Instructs not to map CLSID values to ProgID values. - - - Identifies the value of the supplied file parameter (3rd parameter of function GetFileAssociation()) as an executable file name. - If this flag is not set, the root key will be set to the ProgID associated with the .exe key instead of the executable file's ProgID. - - - Specifies that when an IQueryAssociation method does not find the requested value under the root key, it should attempt to retrieve the comparable value from the * subkey. - - - Specifies that when an IQueryAssociation method does not find the requested value under the root key, it should attempt to retrieve the comparable value from the Folder subkey. - - - Specifies that only HKEY_CLASSES_ROOT should be searched, and that HKEY_CURRENT_USER should be ignored. - - - Specifies that the return string should not be truncated. Instead, return an error value and the required size for the complete string. - - - - Instructs IQueryAssociations methods to verify that data is accurate. - This setting allows IQueryAssociations methods to read data from the user's hard disk for verification. - For example, they can check the friendly name in the registry against the one stored in the .exe file. - - Setting this flag typically reduces the efficiency of the method. - - - - Instructs IQueryAssociations methods to ignore Rundll.exe and return information about its target. - Typically IQueryAssociations methods return information about the first .exe or .dll in a command string. - If a command uses Rundll.exe, setting this flag tells the method to ignore Rundll.exe and return information about its target. - - - - Instructs IQueryAssociations methods not to fix errors in the registry, such as the friendly name of a function not matching the one found in the .exe file. - - - Specifies that the BaseClass value should be ignored. - - - Specifies that the "Unknown" ProgID should be ignored; instead, fail. - Introduced in Windows 7. - - - Specifies that the supplied ProgID should be mapped using the system defaults, rather than the current user defaults. - Introduced in Windows 8. - - - Specifies that the value is a protocol, and should be mapped using the current user defaults. - Introduced in Windows 8. - - - ASSOCSTR enumeration - Used by the AssocQueryString() function to define the type of string that is to be returned. - - - None. - - - A command string associated with a Shell verb. - - - - An executable from a Shell verb command string. - For example, this string is found as the (Default) value for a subkey such as HKEY_CLASSES_ROOT\ApplicationName\shell\Open\command. - If the command uses Rundll.exe, set the flag in the attributes parameter of IQueryAssociations::GetString to retrieve the target executable. - - - - The friendly name of a document type. - - - The friendly name of an executable file. - - - Ignore the information associated with the open subkey. - - - Look under the ShellNew subkey. - - - A template for DDE commands. - - - The DDE command to use to create a process. - - - The application name in a DDE broadcast. - - - The topic name in a DDE broadcast. - - - - Corresponds to the InfoTip registry value. - Returns an info tip for an item, or list of properties in the form of an IPropertyDescriptionList from which to create an info tip, such as when hovering the cursor over a file name. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Corresponds to the QuickTip registry value. This is the same as , except that it always returns a list of property names in the form of an IPropertyDescriptionList. - The difference between this value and is that this returns properties that are safe for any scenario that causes slow property retrieval, such as offline or slow networks. - Some of the properties returned from might not be appropriate for slow property retrieval scenarios. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Corresponds to the TileInfo registry value. Contains a list of properties to be displayed for a particular file type in a Windows Explorer window that is in tile view. - This is the same as , but, like , it also returns a list of property names in the form of an IPropertyDescriptionList. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Describes a general type of MIME file association, such as image and bmp, - so that applications can make general assumptions about a specific file type. - - - - - Returns the path to the icon resources to use by default for this association. - Positive numbers indicate an index into the dll's resource table, while negative numbers indicate a resource ID. - An example of the syntax for the resource is "c:\myfolder\myfile.dll,-1". - - - - - For an object that has a Shell extension associated with it, - you can use this to retrieve the CLSID of that Shell extension object by passing a string representation - of the IID of the interface you want to retrieve as the pwszExtra parameter of IQueryAssociations::GetString. - For example, if you want to retrieve a handler that implements the IExtractImage interface, - you would specify "{BB2E617C-0920-11d1-9A0B-00C04FC2D6C1}", which is the IID of IExtractImage. - - - - - For a verb invoked through COM and the IDropTarget interface, you can use this flag to retrieve the IDropTarget object's CLSID. - This CLSID is registered in the DropTarget subkey. - The verb is specified in the supplied file parameter in the call to IQueryAssociations::GetString. - - - - - For a verb invoked through COM and the IExecuteCommand interface, you can use this flag to retrieve the IExecuteCommand object's CLSID. - This CLSID is registered in the verb's command subkey as the DelegateExecute entry. - The verb is specified in the supplied file parameter in the call to IQueryAssociations::GetString. - - - - (No description available on MSDN) - Introduced in Windows 8. - - - The maximum defined value, used for validation purposes. - - - Shell32 FileAttributes structure, used to retrieve the different types of a file system object. - - - 0x000000000 - Get file system object large icon. - The flag must also be set. - - - 0x000000001 - Get file system object small icon. - The flag must also be set. - - - 0x000000002 - Get file system object open icon. - A container object displays an open icon to indicate that the container is open. - The and/or flag must also be set. - - - 0x000000004 - Get file system object Shell-sized icon. - If this attribute is not specified the function sizes the icon according to the system metric values. - - - 0x000000008 - Get file system object by its PIDL. - Indicate that the given file contains the address of an ITEMIDLIST structure rather than a path name. - - - 0x000000010 - Indicates that the given file should not be accessed. Rather, it should act as if the given file exists and use the supplied attributes. - This flag cannot be combined with the , or attributes. - - - 0x000000020 - Apply the appropriate overlays to the file's icon. - The flag must also be set. - - - 0x000000040 - Returns the index of the overlay icon. - The value of the overlay index is returned in the upper eight bits of the iIcon member of the structure specified by psfi. - - - 0x000000100 - Retrieve the handle to the icon that represents the file and the index of the icon within the system image list. The handle is copied to the member of the structure, and the index is copied to the member. - - - 0x000000200 - Retrieve the display name for the file. The name is copied to the member of the structure. - The returned display name uses the long file name, if there is one, rather than the 8.3 form of the file name. - - - 0x000000400 - Retrieve the string that describes the file's type. - - - 0x000000800 - Retrieve the item attributes. The attributes are copied to the member of the structure. - Will touch every file, degrading performance. - - - 0x000001000 - Retrieve the name of the file that contains the icon representing the file specified by pszPath. The name of the file containing the icon is copied to the member of the structure. The icon's index is copied to that structure's member. - - - 0x000002000 - Retrieve the type of the executable file if pszPath identifies an executable file. - This flag cannot be specified with any other attributes. - - - 0x000004000 - Retrieve the index of a system image list icon. - - - 0x000008000 - Add the link overlay to the file's icon. - The flag must also be set. - - - 0x000010000 - Blend the file's icon with the system highlight color. - - - 0x000020000 - Modify to indicate that contains specific attributes that are desired. - This flag cannot be specified with the attribute. Will touch every file, degrading performance. - - - SHFILEINFO structure, contains information about a file system object. - - - A handle to the icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - - The index of the icon image within the system image list. - - - An array of values that indicates the attributes of the file object. - - - The name of the file as it appears in the Windows Shell, or the path and file name of the file that contains the icon representing the file. - - - The type of file. - - - SFGAO - Attributes that can be retrieved from a file system object. - - - 0x00000000 - None. - - - 0x00000001 - The specified items can be copied. - - - 0x00000002 - The specified items can be moved. - - - 0x00000004 - Shortcuts can be created for the specified items. - - - 0x00000008 - The specified items can be bound to an IStorage object through IShellFolder::BindToObject. For more information about namespace manipulation capabilities, see IStorage. - - - 0x00000010 - The specified items can be renamed. Note that this value is essentially a suggestion; not all namespace clients allow items to be renamed. However, those that do must have this attribute set. - - - 0x00000020 - The specified items can be deleted. - - - 0x00000040 - The specified items have property sheets. - - - 0x00000100 - The specified items are drop targets. - - - 0x00001000 - The specified items are system items. - Windows 7 and later. - - - 0x00002000 - The specified items are encrypted and might require special presentation. - - - 0x00004000 - Accessing the item (through IStream or other storage interfaces) is expected to be a slow operation. - - - 0x00008000 - The specified items are shown as dimmed and unavailable to the user. - - - 0x00010000 - The specified items are shortcuts. - - - 0x00020000 - The specified objects are shared. - - - 0x00040000 - The specified items are read-only. In the case of folders, this means that new items cannot be created in those folders. - - - 0x00080000 - The item is hidden and should not be displayed unless the Show hidden files and folders option is enabled in Folder Settings. - - - 0x00100000 - The items are nonenumerated items and should be hidden. They are not returned through an enumerator such as that created by the IShellFolder::EnumObjects method. - - - 0x00200000 - The items contain new content, as defined by the particular application. - - - 0x00400000 - Indicates that the item has a stream associated with it. - - - 0x00800000 - Children of this item are accessible through IStream or IStorage. - - - 0x01000000 - When specified as input, instructs the folder to validate that the items contained in a folder or Shell item array exist. - - - 0x02000000 - The specified items are on removable media or are themselves removable devices. - - - 0x04000000 - The specified items are compressed. - - - 0x08000000 - The specified items can be hosted inside a web browser or Windows Explorer frame. - - - 0x10000000 - The specified folders are either file system folders or contain at least one descendant (child, grandchild, or later) that is a file system folder. - - - 0x20000000 - The specified items are folders. - - - 0x40000000 - The specified folders or files are part of the file system (that is, they are files, directories, or root directories). - - - 0x80000000 - The specified folders have subfolders. - - - Used by method UrlIs() to define a URL type. - - - Is the URL valid? - - - Is the URL opaque? - - - Is the URL a URL that is not typically tracked in navigation history? - - - Is the URL a file URL? - - - Attempt to determine a valid scheme for the URL. - - - Does the URL string end with a directory? - - - Does the URL have an appended query string? - - - Destroys an icon and frees any memory the icon occupied. - An handle to an icon. - - - Gets the file or protocol that is associated with from the registry. - A path to the file. - The associated file- or protocol-related string from the registry or string.Empty if no association can be found. - - - Gets the content-type that is associated with from the registry. - A path to the file. - The associated file- or protocol-related content-type from the registry or string.Empty if no association can be found. - - - Gets the default icon that is associated with from the registry. - A path to the file. - The associated file- or protocol-related default icon from the registry or string.Empty if no association can be found. - - - Gets the friendly application name that is associated with from the registry. - A path to the file. - The associated file- or protocol-related friendly application name from the registry or string.Empty if no association can be found. - - - Gets the friendly document name that is associated with from the registry. - A path to the file. - The associated file- or protocol-related friendly document name from the registry or string.Empty if no association can be found. - - - Gets an handle to the Shell icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - The path to the file system object which should not exceed maximum path length. Both absolute and - relative paths are valid. - - - Icon size or . Can also be combined - with and others. - - An handle to the Shell icon that represents the file, or IntPtr.Zero on failure. - - - Retrieves information about an object in the file system, such as a file, folder, directory, or drive root. - A struct instance. - - You should call this function from a background thread. - Failure to do so could cause the UI to stop responding. - Unicode path are supported. - - The path to the file system object which should not exceed the maximum path length. Both absolute and relative paths are valid. - A attribute. - One ore more attributes. - - suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - - - Retrieves an instance of containing information about the specified file. - A path to the file. - A class instance. - - - Retrieves an instance of containing information about the specified file. - A path to the file. - Indicates the format of the path parameter(s). - A class instance. - - - Gets the "Open With" command that is associated with from the registry. - A path to the file. - The associated file- or protocol-related "Open With" command from the registry or string.Empty if no association can be found. - - - Gets the Shell command that is associated with from the registry. - A path to the file. - The associated file- or protocol-related Shell command from the registry or string.Empty if no association can be found. - - - Converts a file URL to a Microsoft MS-DOS path. - The file URL. - - The Microsoft MS-DOS path. If no path can be created, string.Empty is returned. - If is , will also be returned. - - - - Creates a path from a file URL. - The URL. - - The file path. If no path can be created, string.Empty is returned. - If is , will also be returned. - - - - Determines whether a path to a file system object such as a file or folder is valid. - The full path of maximum length the maximum path length to the object to verify. - if the file exists; otherwise - - - Tests whether a URL is a specified type. - The URL. - - - For all but one of the URL types, UrlIs returns if the URL is the specified type, or otherwise. - If UrlIs is set to , UrlIs will attempt to determine the URL scheme. - If the function is able to determine a scheme, it returns , or otherwise. - - - - Converts a Microsoft MS-DOS path to a canonicalized URL. - The full MS-DOS path of maximum length . - - The URL. If no URL can be created string.Empty is returned. - If is , will also be returned. - - - - Tests a URL to determine if it is a file URL. - The URL. - if the URL is a file URL, or otherwise. - - - Returns whether a URL is a URL that browsers typically do not include in navigation history. - The URL. - if the URL is a URL that is not included in navigation history, or otherwise. - - - Returns whether a URL is opaque. - The URL. - if the URL is opaque, or otherwise. - - - Searches for and retrieves a file or protocol association-related string from the registry. - A path to a file. - One or more attributes. Only one "InitXXX" attribute can be used. - A attribute. - The associated file- or protocol-related string from the registry or string.Empty if no association can be found. - - - - Retrieve information about an object in the file system, such as a file, folder, directory, or drive root. - A struct instance. - - You should call this function from a background thread. - Failure to do so could cause the UI to stop responding. - Unicode path are not supported. - - The path to the file system object which should not exceed the maximum path length in length. Both absolute and relative paths are valid. - A attribute. - A attribute. - Checks that the path contains only valid path-characters. - - suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - - - Indicates whether the link target is a file or directory. - Used by Win32 API CreateSymbolicLink()/CreateSymbolicLinkTransacted() - - - The link target is a file. - - - The link target is a directory. - - - Represents information about a symbolic link. - - - Gets the type of the link. - The type of the link. - - - Specifies the type of a symbolic link. - - - The symbolic link is absolute. - - - The symbolic link is relative. - - - The function attempted to use a name that is reserved for use by another transaction. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - The function attempted to use a name that is reserved for use by another transaction. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - The remote server or share does not support transacted file operations. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The object that holds the serialized object data. - The contextual information about the source or destination. - - - The transaction handle associated with this operation is not valid. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - A KTM transaction object for use with the transacted operations in - - - Initializes a new instance of the class, internally using the specified . - This method allows the usage of methods accepting a with an instance of . - - The transaction to use for any transactional operations. - - - Initializes a new instance of the class with a default security descriptor, infinite timeout and no description. - - - Initializes a new instance of the class with a default security descriptor. - The time, in milliseconds, when the transaction will be aborted if it has not already reached the prepared state. - A user-readable description of the transaction. This parameter may be . - - - Initializes a new instance of the class. - The security descriptor. - The time, in milliseconds, when the transaction will be aborted if it has not already reached the prepared state. - Specify 0 to provide an infinite timeout. - A user-readable description of the transaction. This parameter may be . - - - Requests that the specified transaction be committed. - - - - - - Requests that the specified transaction be rolled back. This function is synchronous. - - - - - Gets the safe handle. - The safe handle. - - - Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. - - - Represents a wrapper class for a handle used by the FindFirstFile/FindNextFile Win32 API functions. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - Represents a wrapper class for a handle used by the FindFirstVolumeMountPoint/FindVolumeMountPointClose methods of the Win32 API. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . - - - - Represents a wrapper class for a handle used by the FindFirstVolume/FindNextVolume methods of the Win32 API. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - - Provides a concrete implementation of SafeHandle supporting transactions. - - - Initializes a new instance of the class. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - It is too late to perform the requested operation, since the Transaction has already been aborted. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - It is too late to perform the requested operation, since the Transaction has already been committed. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The object that holds the serialized object data. - The contextual information about the source or destination. - - - The exception that is thrown when an attempt to create a file or directory that already exists was made. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - Static class providing utility methods for working with Microsoft Windows devices and volumes. - - - Defines, redefines, or deletes MS-DOS device names. - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - An MS-DOS path that will implement this device. - - - Defines, redefines, or deletes MS-DOS device names. - - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - - - >An MS-DOS path that will implement this device. If parameter has the - flag specified, is used as is. - - - The controllable aspects of the DefineDosDevice function, flags which will be combined with the - default. - - - - Deletes an MS-DOS device name. - An MS-DOS device name specifying the device to delete. - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - The controllable aspects of the DefineDosDevice function flags which will be combined with the - default. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - - Retrieves a list of all existing MS-DOS device names. - An with one or more existing MS-DOS device names. - - - Retrieves a list of all existing MS-DOS device names. - - (Optional, default: ) An MS-DOS device name string specifying the target of the query. This parameter can be - "sort". In that case a sorted list of all existing MS-DOS device names is returned. This parameter can be . - In that case, the function will store a list of all existing MS-DOS device names into the buffer. - - An with or more existing MS-DOS device names. - - - - Retrieves information about MS-DOS device names. The function can obtain the current mapping for a particular MS-DOS device name. - The function can also obtain a list of all existing MS-DOS device names. - - - An MS-DOS device name string, or part of, specifying the target of the query. This parameter can be . In that - case, the QueryDosDevice function will store a list of all existing MS-DOS device names into the buffer. - - - (Optional, default: ) If options[0] = a sorted list will be returned. - - An with one or more existing MS-DOS device names. - - - Gets the name of the file system, such as NTFS or FAT32. - Use DriveFormat to determine what formatting a drive uses. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - The name of the file system on the specified drive or on failure or if not available. - - - Gets the drive letter from an MS-DOS device name. For example: "\Device\HarddiskVolume2" returns "C:\". - An MS-DOS device name. - The drive letter from an MS-DOS device name. - - - - Determines, based on the root of the current directory, whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network - drive. - - A object. - - - Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive. - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\" - A object. - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, the total - amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - A class instance. - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, the total - amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - - gets both size- and disk cluster information. Get only disk cluster information, - Get only size information. - - A class instance. - - - Gets a value indicating whether a drive is ready. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - if is ready; otherwise, . - - - Deletes the label of the file system volume that is the root of the current directory. - - - - Deletes the label of a file system volume. - - The root directory of a file system volume. This is the volume the function will remove the label. - - - Deletes a Drive letter or mounted folder. - Deleting a mounted folder does not cause the underlying directory to be deleted. - - If the parameter is a directory that is not a mounted folder, the function does nothing. The - directory is not deleted. - - - It's not an error to attempt to unmount a volume from a volume mount point when there is no volume actually mounted at that volume - mount point. - - The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\. - - - - Returns an enumerable collection of of all mounted folders (volume mount points) on the specified volume. - - - - A containing the volume . - An enumerable collection of of all volume mount points on the specified volume. - - - - Returns an enumerable collection of drive letters and mounted folder paths for the specified volume. - - - - A volume path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\. - An enumerable collection of containing the path names for the specified volume. - - - Returns an enumerable collection of volumes on the computer. - An enumerable collection of volume names on the computer. - - - - Get the unique volume name for the given path. - - - - A path string. Both absolute and relative file and directory names, for example "..", is acceptable in this path. If you specify a - relative file or directory name without a volume qualifier, GetUniqueVolumeNameForPath returns the Drive letter of the current - volume. - - - Returns the unique volume name in the form: "\\?\Volume{GUID}\", - or on error or if unavailable. - - - - Retrieves the Win32 Device name from the Volume name. - - Name of the Volume. - - The Win32 Device name from the Volume name (for example: "\Device\HarddiskVolume2"), or on error or if - unavailable. - - - - Gets the shortest display name for the specified . - This method basically returns the shortest string returned by - A volume path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\. - - The shortest display name for the specified volume found, or if no display names were found. - - - - - Retrieves a volume path for the volume that is associated with the specified volume mount point (drive letter, - volume GUID path, or mounted folder). - - - - The path of a mounted folder (for example, "Y:\MountX\") or a drive letter (for example, "X:\"). - - The unique volume name of the form: "\\?\Volume{GUID}\". - - - - Tranlates DosDevicePath to a Volume GUID. For example: "\Device\HarddiskVolumeX\path\filename.ext" can translate to: "\path\ - filename.ext" or: "\\?\Volume{GUID}\path\filename.ext". - - A DosDevicePath, for example: \Device\HarddiskVolumeX\path\filename.ext. - A translated dos path. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - A path that contains the root directory. - A instance describing the volume associatied with the specified root directory. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - An instance to a handle. - A instance describing the volume associatied with the specified root directory. - - - Retrieve the label of a file system volume. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - - The the label of the file system volume. This function can return string.Empty since a volume label is generally not - mandatory. - - - - Retrieves the volume mount point where the specified path is mounted. - - The path to the volume, for example: "C:\Windows". - - Returns the nearest volume root path for a given directory. - The volume path name, for example: "C:\Windows" returns: "C:\". - - - - Determines whether the volume of two file system objects is the same. - The first filesystem ojbect with full path information. - The second file system object with full path information. - if both filesytem objects reside on the same volume, otherwise. - - - Determines whether the specified volume name is a defined volume on the current computer. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - on success, otherwise. - - - Sets the label of the file system volume that is the root of the current directory. - - A name for the volume. - - - Sets the label of a file system volume. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\" - If this parameter is , the function uses the current drive. - - - A name for the volume. - If this parameter is , the function deletes any existing label - from the specified volume and does not assign a new label. - - - - Associates a volume with a Drive letter or a directory on another volume. - - - - The user-mode path to be associated with the volume. This may be a Drive letter (for example, "X:\") - or a directory on another volume (for example, "Y:\MountX\"). - - A containing the volume . - - - Defines, redefines, or deletes MS-DOS device names. - - - defines a new MS-DOS device. deletes a previously defined MS-DOS device. - - - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - The controllable aspects of the DefineDosDevice function, flags which will be combined with the - default. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - on success, otherwise. - - - Deletes a Drive letter or mounted folder. - - It's not an error to attempt to unmount a volume from a volume mount point when there is no volume actually mounted at that volume mount point. - Deleting a mounted folder does not cause the underlying directory to be deleted. - - - The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - If completed successfully returns , otherwise the last error number. - - - Contains information about a filesystem Volume. - - - Initializes a VolumeInfo instance. - - - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share. - - - Initializes a VolumeInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: "\\server\share". - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Initializes a VolumeInfo instance. - An instance to a handle. - - - Initializes a VolumeInfo instance. - An instance to a handle. - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Refreshes the state of the object. - - - Returns the full path of the volume. - A string that represents this instance. - - - The specified volume supports preserved case of file names when it places a name on disk. - - - The specified volume supports case-sensitive file names. - - - The specified volume supports file-based compression. - - - Gets the name of the file system, for example, the FAT file system or the NTFS file system. - The name of the file system. - - - The full path to the volume. - - - The volume GUID. - - - Gets the maximum length of a file name component that the file system supports. - The maximum length of a file name component that the file system supports. - - - Gets the label of the volume. - The label of the volume. - This property is the label assigned to the volume, such "MyDrive" - - - The specified volume supports named streams. - - - The specified volume preserves and enforces access control lists (ACL). - - - The specified volume is read-only. - - - The specified volume supports a single sequential write. - - - Gets the volume serial number that the operating system assigns when a hard disk is formatted. - The volume serial number that the operating system assigns when a hard disk is formatted. - - - The specified volume supports the Encrypted File System (EFS). - - - The specified volume supports extended attributes. - - - The specified volume supports hard links. - - - The specified volume supports object identifiers. - - - The file system supports open by FileID. - - - The specified volume supports remote storage. (This property does not appear on MSDN) - - - The specified volume supports re-parse points. - - - The specified volume supports sparse files. - - - The specified volume supports transactions. - - - The specified volume supports update sequence number (USN) journals. - - - The specified volume supports Unicode in file names as they appear on disk. - - - The specified volume is a compressed volume, for example, a DoubleSpace volume. - - - The specified volume supports disk quotas. - - - Contains information about a Distributed File System (DFS) root or link. This class cannot be inherited. - This structure contains the name, status, GUID, time-out, number of targets, and information about each target of the root or link. - - - - Initializes a new instance of the class which acts as a wrapper for a DFS root or link target. - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - An initialized instance. - - - Returns the Universal Naming Convention (UNC) path of the DFS root or link. - A string that represents this instance. - - - The instance of the DFS root or link. - - - The comment of the DFS root or link. - - - The Universal Naming Convention (UNC) path of the DFS root or link. - - - Specifies the GUID of the DFS root or link. - - - The collection of DFS targets of the DFS root or link. - - - An enum that specifies a set of bit flags that describe the DFS root or link. - - - Specifies the time-out, in seconds, of the DFS root or link. - - - Specifies a set of flags that describe specific properties of a DFS namespace, root, or link. - - - For domain-based DFS namespaces, this member specifies the size of the corresponding Active Directory data blob, in bytes. - For stand-alone DFS namespaces, this field specifies the size of the metadata stored in the registry, - including the key names and value names, in addition to the specific data items associated with them. This field is valid for DFS roots only. - - - - Pointer to a SECURITY_DESCRIPTOR structure that specifies a self-relative security descriptor to be associated with the DFS link's reparse point. - This field is valid for DFS links only. - - - - Contains information about a DFS root or link target in a DFS namespace or from the cache maintained by the DFS client. - This class cannot be inherited. - - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - An initialized instance. - - - The share name of the DFS root target or link target. - A string that represents this instance. - - - The server name of the DFS root target or link target. - - - The share name of the DFS root target or link target. - - - An enum of the DFS root target or link target. - - - Contains a DFS target's priority class and rank. - - - Specifies the priority rank value of the target. The default value is 0, which indicates the highest priority rank within a priority class. - - - A set of bit flags that describe specific properties of a DFS namespace, root, or link. - - - No property flag. - - - DFS_PROPERTY_FLAG_INSITE_REFERRALS - - Scope: Domain roots, stand-alone roots, and links. - If this flag is set at the DFS root, it applies to all links; otherwise, the value of this flag is considered for each individual link. - - - When this flag is set, a DFS referral response from a DFS server for a DFS root or link with the "INSITE" option enabled contains only - those targets which are in the same site as the DFS client requesting the referral. - Targets in the two global priority classes are always returned, regardless of their site location. - - - - - DFS_PROPERTY_FLAG_ROOT_SCALABILITY - - Scope: The entire DFS namespace for a domain-based DFS namespace only. - - - By default, a DFS root target server polls the PDS to detect changes to the DFS metadata. - To prevent heavy server load on the PDC, root scalability can be enabled for the DFS namespace. - Setting this flag will cause the DFS server to poll the nearest domain controller instead of the PDC for DFS metadata changes for the common namespace. - Note that any changes made to the metadata must still occur on the PDC, however. - - - - - DFS_PROPERTY_FLAG_SITE_COSTING - - Scope: The entire DFS namespace for both domain-based and stand-alone DFS namespaces. - - - By default, targets returned in a referral response from a DFS server to a DFS client for a DFS root or link - consists of two groups: targets in the same site as the client, and targets outside the site. - - - If site-costing is enabled for the Active Directory, the response can have more than two groups, - with each group containing targets with the same site cost for the specific DFS client requesting the referral. - The groups are ordered by increasing site cost. For more information about how site-costing is used to prioritize targets. - - - - - DFS_PROPERTY_FLAG_TARGET_FAILBACK - - Scope: Domain-based DFS roots, stand-alone DFS roots, and DFS links. - If this flag is set at the DFS root, it applies to all links; otherwise, the value of this flag is considered for each individual link. - - - When this flag is set, optimal target failback is enabled for V4 DFS clients, - allowing them to fail back to an optimal target after failing over to a non-optimal one. - The target failback setting is provided to the DFS client in a V4 referral response by a DFS server. - - - - - DFS_PROPERTY_FLAG_CLUSTER_ENABLED - Scope: Stand-alone DFS roots and links only. - The DFS root is clustered to provide high availability for storage failover. - - - - DFS_PROPERTY_FLAG_ABDE - Scope: Domain-based DFS roots and stand-alone DFS roots. - When this flag is set, Access-Based Directory Enumeration (ABDE) mode support is enabled on the entire DFS root target share of the DFS namespace. - - - - Defines the set of possible DFS target priority class settings. - - - The priority class is not valid. - - - The middle or "normal" site cost priority class for a DFS target. - - - The highest priority class for a DFS target. Targets assigned this class receive global preference. - - - The highest site cost priority class for a DFS target. Targets assigned this class receive the most preference among targets of the same site cost for a given DFS client. - - - The lowest site cost priority class for a DFS target. Targets assigned this class receive the least preference among targets of the same site cost for a given DFS client. - - - The lowest level of priority class for a DFS target. Targets assigned this class receive the least preference globally. - - - The information level. - - - No specific information level used. - - - Contains information about the shared resource, including the name and type of the resource, and a comment associated with the resource. - - - Contains information about the shared resource, including the name, type, and permissions of the resource, comments associated with the resource, - the maximum number of concurrent connections, the number of current connections, the local path for the resource, and a password for the current connection. - - - - Contains information about the shared resource, including the server name, name of the resource, type, and permissions, - the number of connections, and other pertinent information. - - - - Contains information about the shared resource. - - - NETRESOURCE structure. - ResourceUsage: A set of bit flags describing how the resource can be used. - - Note that this member can be specified only if the member is equal to . - - - RESOURCEUSAGE_CONNECTABLE - The resource is a connectable resource. - The name pointed to by the lpRemoteName member can be passed to the WNetAddConnection function to make a network connection. - - - - RESOURCEUSAGE_CONTAINER - The resource is a container resource. - The name pointed to by the lpRemoteName member can be passed to the WNetAddConnection function to make a network connection. - - - - RESOURCEUSAGE_NOLOCALDEVICE - The resource is not a local device. - - - - RESOURCEUSAGE_SIBLING - The resource is a sibling. - This value is not used by Windows. - - - - RESOURCEUSAGE_ATTACHED - The resource must be attached. - This value specifies that a function to enumerate this resource should fail - if the caller is not authenticated, even if the network permits enumeration without authentication. - - - - RESOURCEUSAGE_ALL - Setting this value is equivalent to setting: , , and . - - - - NETRESOURCE structure. - ResourceType: The type of resource. - - If a network provider cannot distinguish between - print and disk resources, it can enumerate all resources. - - - - - RESOURCETYPE_ANY - ResourceType: All resources. - - If a network provider cannot distinguish between print and disk resources, it can enumerate all resources. - This value cannot be combined with or . - - - - - RESOURCETYPE_DISK - All disk resources. - - - - RESOURCETYPE_PRINT - All print resources. - - - - NETRESOURCE structure. - ResourceScope: The scope of the enumeration. - - - - RESOURCE_CONNECTED - Enumerate all currently connected resources. - The function ignores the parameter. - - - - RESOURCE_GLOBALNET - Enumerate all resources on the network. - - - - RESOURCE_REMEMBERED - Enumerate all remembered (persistent) connections. - The function ignores the parameter. - - - - RESOURCE_RECENT - - - RESOURCE_CONTEXT - Enumerate only resources in the network context of the caller. Specify this value for a Network Neighborhood view. - The function ignores the parameter. - - - - The display options for the network object in a network browsing user interface. - - - RESOURCEDISPLAYTYPE_GENERIC - The method used to display the object does not matter. - - - - RESOURCEDISPLAYTYPE_DOMAIN - The object should be displayed as a domain. - - - - RESOURCEDISPLAYTYPE_SERVER - The object should be displayed as a server. - - - - RESOURCEDISPLAYTYPE_SHARE - The object should be displayed as a share - - - - RESOURCEDISPLAYTYPE_FILE - The object should be displayed as a file. - - - - RESOURCEDISPLAYTYPE_GROUP - The object should be displayed as a group. - - - - RESOURCEDISPLAYTYPE_NETWORK - The object should be displayed as a network. - - - - RESOURCEDISPLAYTYPE_ROOT - The object should be displayed as a logical root for the entire network. - - - - RESOURCEDISPLAYTYPE_SHAREADMIN - The object should be displayed as a administrative share. - - - - RESOURCEDISPLAYTYPE_DIRECTORY - The object should be displayed as a directory. - - - - RESOURCEDISPLAYTYPE_TREE - The object should be displayed as a tree. - - - - RESOURCEDISPLAYTYPE_NDSCONTAINER - The object should be displayed as a Netware Directory Service container. - - - - Used by function WNetUseConnection(); Set of bit flags describing the connection. This parameter can be any combination of the following values. - - - No Connect options are used. - - - This flag instructs the operating system to store the network resource connection. If this bit flag is set, the operating system automatically attempts to restore the connection when the user logs on. The system remembers only successful connections that redirect local devices. It does not remember connections that are unsuccessful or deviceless connections. - - - If this flag is set, the operating system may interact with the user for authentication purposes. - - - This flag instructs the system not to use any default settings for user names or passwords without offering the user the opportunity to supply an alternative. This flag is ignored unless is also set. - - - This flag forces the redirection of a local device when making the connection. - - - If this flag is set, and the operating system prompts for a credential, the credential should be saved by the credential manager. If the credential manager is disabled for the caller's logon session, or if the network provider does not support saving credentials, this flag is ignored. This flag is also ignored unless you set the "CommandLine" flag. - - - Contains the name and type (domain-based or stand-alone) of a DFS namespace. - Minimum supported client: Windows XP with SP1 [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - - DFS_VOLUME_FLAVOR_STANDALONE - Specifies a stand-alone DFS namespace. - - - - DFS_VOLUME_FLAVOR_AD_BLOB - Specifies a domain-based DFS namespace. - - - - DFS_VOLUME_FLAVORS bitmask (0x00000300) - Used to extract the DFS namespace flavor. - - - - The WNetCancelConnection function cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - The WNetGetUniversalName function takes a drive-based path for a network resource and returns an information structure that contains a more universal form of the name. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - The WNetUseConnection function creates a connection to a network resource. The function can redirect a local device to a network resource. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Lists all connections made to a shared resource on the server or all connections established from a particular computer. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - If there is more than one user using this connection, then it is possible to get more than one structure for the same connection, but with a different user name. - Administrator, Server or Print Operator, or Power User group membership is required to successfully execute the NetConnectionEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Forces a resource to close. This function can be used when an error prevents closure by any other means. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - You should use NetFileClose with caution because it does not write data cached on the client system to the file before closing the file. - Only members of the Administrators or Server Operators local group can successfully execute the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Returns information about some or all open files on a server, depending on the parameters specified. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - Only members of the Administrators or Server Operators local group can successfully execute the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves information about each (hidden) Server Message Block (SMB) resource/share on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - For interactive users (users who are logged on locally to the machine), no special group membership is required to execute the NetShareEnum function. - For non-interactive users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareEnum function at levels 2, 502, and 503. No special group membership is required for level 0 or level 1 calls. - This function applies only to Server Message Block (SMB) shares. - Windows Server 2003 and Windows XP: For all users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareEnum function at levels 2 and 502. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves information about a particular Server Message Block (SMB) shared resource on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - For interactive users (users who are logged on locally to the machine), no special group membership is required to execute the NetShareGetInfo function. - For non-interactive users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareGetInfo function at levels 2, 502, and 503. - This function applies only to Server Message Block (SMB) shares. - Windows Server 2003 and Windows XP: For all users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareGetInfo function at levels 2 and 502. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - The NetServerDiskEnum function retrieves a list of disk drives on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - The function returns an array of three-character strings (a drive letter, a colon, and a terminating null character). - Only members of the Administrators or Server Operators local group can successfully execute the NetServerDiskEnum function on a remote computer. - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Enumerates the Distributed File System (DFS) namespaces hosted on a server or DFS links of a namespace hosted by a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsEnum function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - Retrieves information about a Distributed File System (DFS) root or link from the cache maintained by the DFS client. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsGetClientInfo function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - Retrieves information about a specified Distributed File System (DFS) root or link in a DFS namespace. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsGetInfo function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - A constant of type DWORD that is set to –1. This value is valid as an input parameter to any method in section 3.1.4 that takes a PreferedMaximumLength parameter. When specified as an input parameter, this value indicates that the method MUST allocate as much space as the data requires. - MSDN "2.2.2.2 MAX_PREFERRED_LENGTH": http://msdn.microsoft.com/en-us/library/cc247107.aspx - - - Contains the name, status, GUID, time-out, property flags, metadata size, DFS target information, link reparse point security descriptor, and a list of DFS targets for a root or link. - Minimum supported client: Windows Vista with SP1 - Minimum supported server: Windows Server 2008 - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - The comment associated with the DFS root or link. - - - A that specifies a set of bit flags that describe the DFS root or link. - - - Specifies the time-out, in seconds, of the DFS root or link. - - - Specifies the GUID of the DFS root or link. - - - Specifies a set of flags that describe specific properties of a DFS namespace, root, or link. - - - For domain-based DFS namespaces, this member specifies the size of the corresponding Active Directory data blob, in bytes. - For stand-alone DFS namespaces, this field specifies the size of the metadata stored in the registry, - including the key names and value names, in addition to the specific data items associated with them. - This field is valid for DFS roots only. - - - - This member is reserved for system use. - - - Pointer to a SECURITY_DESCRIPTOR structure that specifies a self-relative security descriptor to be associated with the DFS link's reparse point. - This field is valid for DFS links only. - - - - Specifies the number of DFS targets. - - - An array of structures. - - - Contains the priority class and rank of a specific DFS target. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 - - - DFS_TARGET_PRIORITY_CLASS enumeration value that specifies the priority class of the target. - - - Specifies the priority rank value of the target. The default value is 0, which indicates the highest priority rank within a priority class. - - - This member is reserved and must be zero. - - - Contains information about a DFS target, including the DFS target server name and share name as well as the target's state and priority. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 - - - State of the target. - - - The DFS root target or link target server name. - - - The DFS root target or link target share name. - - - DFS_TARGET_PRIORITY structure that contains a DFS target's priority class and rank. - - - Contains information about a network resource. - The NETRESOURCE structure is returned during an enumeration of network resources. - The NETRESOURCE structure is also specified when making or querying - a network connection with calls to various Windows Networking functions. - - - - The scope of the enumeration. - - - The type of resource - - - The display options for the network object in a network browsing user interface. - - - A set of bit flags describing how the resource can be used. - - - If the member is equal to or , - this member is a pointer to a -terminated character string that specifies the name of a local device. - This member is if the connection does not use a device. - - - - If the entry is a network resource, this member is a that specifies the remote network name. - If the entry is a current or persistent connection, member points to - the network name associated with the name pointed to by the member. - The can be characters in length, - and it must follow the network provider's naming conventions. - - - - A that contains a comment supplied by the network provider. - - - A that contains the name of the provider that owns the resource. - This member can be if the provider name is unknown. - - - - Contains the identifier and other pertinent information about files, devices, and pipes. - This structure is only for use with the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The identification number assigned to the resource when it is opened. - - - The access permissions associated with the opening application. This member can be one or more of the following values. - - - The number of file locks on the file, device, or pipe. - - - The path of the opened resource. - - - Specifies which user (on servers that have user-level security) or which computer (on servers that have share-level security) opened the resource. - - - Contains the name of a domain-based Distributed File System (DFS) namespace. - This structure is only for use with the NetDfsEnum, NetDfsGetClientInfo, and NetDfsGetInfo functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a domain-based DFS namespace. - - - Contains the name and type (domain-based or stand-alone) of a DFS namespace. - The DFS functions use the structure to enumerate DFS namespaces hosted on a machine. - Minimum supported client: Windows XP with SP1 [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Value that specifies the type of the DFS namespace. This member can be one of the values. - - - The name of a DFS namespace. - This member can have one of the following two formats: - The first format is: \ServerName\DfsName - where ServerName is the name of the root target server that hosts the stand-alone DFS namespace and DfsName is the name of the DFS namespace. - The second format is: - \DomainName\DomDfsName - where DomainName is the name of the domain that hosts the domain-based DFS namespace and DomDfsname is the name of the DFS namespace. - - - - Contains path and name information for a network resource. - - - Identifies a network resource. - - - The name of a network connection. - - - The remaing path. - - - Contains the identification number of a connection, number of open files, connection time, number of users on the connection, and the type of connection. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Specifies a connection identification number. - - - A combination of values that specify the type of connection made from the local device name to the shared resource. - - - Specifies the number of files currently open as a result of the connection. - - - Specifies the number of users on the connection. - - - Specifies the number of seconds that the connection has been established. - - - If the server sharing the resource is running with user-level security, the UserName member describes which user made the connection. If the server is running with share-level security, coni1_username describes which computer (computername) made the connection. - Note that Windows does not support share-level security. - - - String that specifies either the share name of the server's shared resource or the computername of the client. The value of this member depends on which name was specified as the qualifier parameter to the NetConnectionEnum function. - - - Contains information about the shared resource. - This structure can be retrieved by calling the NetShareGetInfo function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - A bitmask of flags that specify information about the shared resource. - - - Contains information about the shared resource, including the name and type of the resource, and a comment associated with the resource. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - Contains information about the shared resource, including the name, type, and permissions of the resource, comments associated with the resource, - the maximum number of concurrent connections, the number of current connections, the local path for the resource, and a password for the current connection. - - Share information, NT, level 2, requires admin rights to work. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The number of current connections to the resource. - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The share's password (when the server is running with share-level security). - - - Contains information about the shared resource, including the server name, name of the resource, type, and permissions, - the number of connections, and other pertinent information. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The number of current connections to the resource. - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The share's password (when the server is running with share-level security). - - - The DNS or NetBIOS name of the remote server on which the shared resource resides. - A value of "*" indicates no configured server name. - - - Reserved; must be zero. - - - Specifies the SECURITY_DESCRIPTOR associated with this share. - - - A set of bit flags that describe the storage state of the DFS root or link target. - - - No storage state. - - - DFS_STORAGE_STATE_OFFLINE - The DFS root or link target is offline. - - Windows Server 2003: The state of a root target cannot be set to DFS_STORAGE_STATE_OFFLINE. - - - DFS_STORAGE_STATE_ONLINE - The DFS root or link target is online. - - - - DFS_STORAGE_STATE_ACTIVE - The DFS root or link target is the active target. - - - - A set of bit flags that describe the state of the DFS root or link; - the state of the DFS namespace root cannot be changed. - One flag is set, and one DFS_VOLUME_FLAVOR flag is set. - - - - No volume state. - - - DFS_VOLUME_STATE_OK - The specified DFS root or link is in the normal state. - - - - DFS_VOLUME_STATE_INCONSISTENT - The internal DFS database is inconsistent with the specified DFS root or link. - Attempts to repair the inconsistency have failed. - - - - DFS_VOLUME_STATE_OFFLINE - The specified DFS root or link is offline or unavailable. - - - - DFS_VOLUME_STATE_ONLINE - The specified DFS root or link is available. - - - - DFS_VOLUME_FLAVOR_STANDALONE - The system sets this flag if the root is associated with a stand-alone DFS namespace. - - Windows XP: This value is not supported. - - - DFS_VOLUME_FLAVOR_AD_BLOB - The system sets this flag if the root is associated with a domain-based DFS namespace. - - Windows XP: This value is not supported. - - - A set of bit flags that describe the permissions for the shared resource's on servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - No permissions. - - - ACCESS_READ - Permission to read data from a resource and, by default, to execute the resource. - - - - ACCESS_WRITE - Permission to write data to the resource. - - - - ACCESS_CREATE - Permission to create an instance of the resource (such as a file); data can be written to the resource as the resource is created. - - - - ACCESS_EXEC - Permission to execute the resource. - - - - ACCESS_DELETE - Permission to delete the resource. - - - - ACCESS_ATRIB - Permission to modify the resource's attributes, such as the date and time when a file was last modified. - - - - ACCESS_PERM - Permission to modify the permissions (read, write, create, execute, and delete) assigned to a resource for a user or application. - - - - ACCESS_ALL - Permission to read, write, create, execute, and delete resources, and to modify their attributes and permissions. - - - - Contains information about the shared resource. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - No specific resource type used. - - - SHI1005_FLAGS_DFS - The specified share is present in a DFS tree structure. This flag cannot be set with NetShareSetInfo. - - - - SHI1005_FLAGS_DFS_ROOT - The specified share is the root volume in a DFS tree structure. This flag cannot be set with NetShareSetInfo. - - - - SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS - The specified share disallows exclusive file opens, where reads to an open file are disallowed. - - - - SHI1005_FLAGS_FORCE_SHARED_DELETE - Shared files in the specified share can be forcibly deleted. - - - - SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING - Clients are allowed to cache the namespace of the specified share. - - - - SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM - The server will filter directory entries based on the access permissions that the user on the client computer has for the server on which the files reside. - Only files for which the user has read access and directories for which the user has FILE_LIST_DIRECTORY access will be returned. If the user has SeBackupPrivilege, all available information will be returned. - - This flag is supported only on servers running Windows Server 2003 with SP1 or later. - - - SHI1005_FLAGS_FORCE_LEVELII_OPLOCK - Prevents exclusive caching modes that can cause delays for highly shared read-only data. - - This flag is supported only on servers running Windows Server 2008 R2 or later. - - - SHI1005_FLAGS_ENABLE_HASH - Enables server-side functionality needed for peer caching support. - Clients on high-latency or low-bandwidth connections can use alternate methods to retrieve data from peers if available, instead of sending requests to the server. - This is only supported on shares configured for manual caching (CSC_CACHE_MANUAL_REINT). - This flag is supported only on servers running Windows Server 2008 R2 or later. - - - SHI1005_FLAGS_ENABLE_CA (0X4000) - Enables server-side functionality needed for peer caching support. Clients on high-latency or low-bandwidth connections can use alternate methods to retrieve data from peers if available, instead of sending requests to the server. This is only supported on shares configured for manual caching (CSC_CACHE_MANUAL_REINT). - Windows 7, Windows Server 2008 R2, Windows Vista, Windows Server 2008, and Windows Server 2003: This flag is not supported. - - - The type of the shared resource. - MSDN: 2.2.2.4 Share Types - http://msdn.microsoft.com/en-us/library/cc247110.aspx - - - - Disk drive. - - - Print queue. - - - Communication device. - - - Interprocess communication (IPC). - - - A cluster share. - - - A Scale-Out cluster share. - - - A DFS share in a cluster. - - - Special share reserved for interprocess communication (IPC$) or remote administration of the server (ADMIN$). - Can also refer to administrative shares such as C$, D$, E$, and so forth. - - - - A temporary share that is not persisted for creation each time the file server initializes. - - - Retriev all known - - - Provides static methods to retrieve network resource information from a local- or remote host. - - - Enumerates open resources from the local host. - open resources from the local host. - - - - - Enumerates open resources from the specified host. - open resources from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - This parameter may be . Enumerates only resources that have the value of the basepath parameter as a prefix. - (A prefix is the portion of a path that comes before a backslash.) - - - This parameter may be . The name of the user or the name of the connection; If - does not begin with two backslashes ("\\") it indicates the name of the user. If begins with two - backslashes ("\\") it indicates the name of the connection. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - >Enumerates open resources from the specified host. - open resources from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - This parameter may be . Enumerates only resources that have the value of the basepath parameter as a prefix. - (A prefix is the portion of a path that comes before a backslash.) - - - This parameter may be . The name of the user or the name of the connection; If - does not begin with two backslashes ("\\") it indicates the name of the user. If begins with two - backslashes ("\\") it indicates the name of the connection. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates drives from the local host. - drives from the local host. - - - - Enumerates local drives from the specified host. - drives from the specified host. - - The DNS or NetBIOS name of the remote server. refers to the local host. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates local drives from the specified host. - drives from the specified host. - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates open connections from the local host. - connection information from the local host. - - - - - Enumerates open connections from the specified host. - connection information from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - The name of the Server Message Block (SMB) share. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets the host and share path name for the given . - The share in the format: \\host\share. - The host and share path. For example, if is: "\\SERVER001\C$\WINDOWS\System32", - its is returned as string[0] = "SERVER001" and string[1] = "\C$\WINDOWS\System32". - If the conversion from local path to UNC path fails, is returned. - - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - The share in the format: \\host\share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - One of the options. - The share in the format: \\host\share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - The DNS or NetBIOS name of the specified host. - The name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - One of the options. - A string that specifies the DNS or NetBIOS name of the specified . - A string that specifies the name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates open connections from the specified host. - connection information from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - The name of the Server Message Block (SMB) share. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from a local or remote host. - shares from the specified host. - This method also enumerates hidden shares. - - - The DNS or NetBIOS name of the specified host. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets the structure of a Server Message Block (SMB) share. - A class, or on failure or when not available, and is . - - One of the options. - A string that specifies the DNS or NetBIOS name of the specified . - A string that specifies the name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS Links from a DFS namespace. - of DFS namespaces. - - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Enumerates the DFS namespaces from the local host. - of DFS Root namespaces from the local host. - - - - - Enumerates the DFS namespaces from a host. - of DFS Root namespaces from a host. - - - The DNS or NetBIOS name of a host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS namespaces from the domain. - of DFS Root namespaces from the domain. - - - - - Enumerates the DFS namespaces from a domain. - of DFS Root namespaces from a domain. - - - A domain name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets information about a DFS root or link from the cache maintained by the DFS client. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Gets information about a DFS root or link from the cache maintained by the DFS client. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - The name of the DFS root target or link target server. - The name of the share corresponding to the DFS root target or link target. - - - Gets information about a specified DFS root or link in a DFS namespace. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Enumerates the DFS namespaces from a host. - of DFS Root namespaces from a host. - - - - The DNS or NetBIOS name of a host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS namespaces from a domain. - of DFS Root namespaces from a domain. - - - - A domain name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about a specified DFS root or link in a DFS namespace. - A instance. - - - - - retrieves information about a Distributed File System (DFS) root or link from the cache maintained by the - DFS client. When retrieves information about a specified Distributed File System (DFS) root or link in a - DFS namespace. - - The Universal Naming Convention (UNC) path of a DFS root or link. - - The name of the DFS root target or link target server. If is , this - parameter is always . - - - The name of the share corresponding to the DFS root target or link target. If is - , this parameter is always . - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - An instance of which provides credentials for password-based authentication schemes such as basic, - digest, NTLM, and Kerberos authentication. - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - An instance of which provides credentials for password-based authentication schemes such as basic, - digest, NTLM, and Kerberos authentication. - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. - - A network resource to connect to, for example: \\server or \\server\share. - - - Creates a connection to a network resource. - - A network resource to connect to, for example: \\server or \\server\share. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. - A network resource to connect to, for example: \\server or \\server\share. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - - Creates a connection to a network resource. - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - A network resource to connect to, for example: \\server or \\server\share. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - Creates a connection to a network resource. - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - A network resource to connect to, for example: \\server or \\server\share. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - The name of a local device to be disconnected, such as "F:". - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - The name of a local device to be disconnected, such as "F:". - - Specifies whether the disconnection should occur if there are open files or jobs on the connection. - If this parameter is , the function fails if there are open files or jobs. - - successful removal of network resource connections will be saved. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - A network resource to disconnect from, for example: \\server or \\server\share. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - A network resource to disconnect from, for example: \\server or \\server\share. - - Specifies whether the disconnection should occur if there are open files or jobs on the connection. - If this parameter is , the function fails if there are open files or jobs. - - successful removal of network resource connections will be saved. - - - Connects to/disconnects from a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - - The . - - - Return the host name in UNC format, for example: \\hostname. - The unc name. - - - Return the host name in UNC format, for example: \\hostname. - Name of the computer. - The unc name. - - - Structure is used to pass additional data to the Win32 function. - - - This method uses level to retieve full REMOTE_NAME_INFO structure. - A structure. - AlphaFS regards network drives created using SUBST.EXE as invalid. - - - - - The local path with drive name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - - The name of a local device to be redirected, such as "F:". When is or string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - - A network resource to connect to/disconnect from, for example: \\server or \\server\share - - - A instance. Use either this or the combination of and . - - - The user name for making the connection. If is , the function uses the default user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function uses the current default password associated with the user specified by . - - - always pops-up an authentication dialog box. - - - successful network resource connections will be saved. - - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - indicates that the operation concerns a drive mapping. - - - indicates that the operation needs to disconnect from the network resource, otherwise connect. - - - Used to create a temporary connection to a network resource that will be disconnected once this instance is disposed. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, using the current user credentials. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, using a user name and password. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, can be supplied. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - - - class destructor. - - - Releases all resources used by the class. - - - Returns the last available drive letter used for this connection. - A string that represents this instance. - - - The last available drive letter used for this connection. - The last available drive letter used for this connection. - - - The path originally specified by the user. - The path originally specified by the user. - - - Contains the identification number of a connection, number of open files, connection time, number of users on the connection, and the type of connection. - - - Create a OpenConnectionInfo instance. - - - Returns the full path to the share. - A string that represents this instance. - - - The local or remote Host. - - - Specifies a connection identification number. - - - The type of share. - - - Specifies the number of files currently open as a result of the connection. - - - Specifies the number of users on the connection. - - - Specifies the number of seconds that the connection has been established. - - - If the server sharing the resource is running with user-level security, the UserName member describes which user made the connection. If the server is running with share-level security, coni1_username describes which computer (computername) made the connection. - - - String that specifies either the share name of the server's shared resource or the computername of the client. The value of this member depends on which name was specified as the qualifier parameter to the NetConnectionEnum function. - - - Contains the identification number and other pertinent information about files, devices, and pipes. This class cannot be inherited. - - - Create a OpenResourceInfo instance. - - - Forces the open resource to close. - You should this method with caution because it does not write data cached on the client system to the file before closing the file. - - - Returns the full path to the share. - A string that represents this instance. - - - The local or remote Host. - - - The identification number assigned to the resource when it is opened. - - - The path of the opened resource. - - - The access permissions associated with the opening application. This member can be one or more of the following values. - - - The number of file locks on the file, device, or pipe. - - - Specifies which user (on servers that have user-level security) or which computer (on servers that have share-level security) opened the resource. - - - Contains information about Server Message Block (SMB) shares. This class cannot be inherited. - - - Creates a instance. - A host to retrieve shares from. - One of the options. - A or instance. - - - Returns the full path to the share. - A string that represents this instance. - - - The number of current connections to the resource. - - - The instance associated with this share. - - - Returns the full UNC path to the share. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The name of a shared resource. - - - The share's password (when the server is running with share-level security). - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - An optional comment about the shared resource. - - - Specifies the SECURITY_DESCRIPTOR associated with this share. - - - A pointer to a string that specifies the DNS or NetBIOS name of the remote server on which the shared resource resides. - A value of "*" indicates no configured server name. - - - The type of share. - - - The type of share resource. - - - The structure level for the ShareInfo instance. - - - Static class providing access to information about the operating system under which the assembly is executing. - - - A set of flags that describe the named Windows versions. - The values of the enumeration are ordered. A later released operating system version has a higher number, so comparisons between named versions are meaningful. - - - A Windows version earlier than Windows 2000. - - - Windows 2000 (Server or Professional). - - - Windows XP. - - - Windows Server 2003. - - - Windows Vista. - - - Windows Server 2008. - - - Windows 7. - - - Windows Server 2008 R2. - - - Windows 8. - - - Windows Server 2012. - - - Windows 8.1. - - - Windows Server 2012 R2 - - - Windows 10 - - - Windows Server - - - A later version of Windows than currently installed. - - - A set of flags to indicate the current processor architecture for which the operating system is targeted and running. - - - PROCESSOR_ARCHITECTURE_INTEL - The system is running a 32-bit version of Windows. - - - - PROCESSOR_ARCHITECTURE_IA64 - The system is running on a Itanium processor. - - - - PROCESSOR_ARCHITECTURE_AMD64 - The system is running a 64-bit version of Windows. - - - - PROCESSOR_ARCHITECTURE_UNKNOWN - Unknown architecture. - - - - Gets a value indicating whether the operating system is a server operating system. - if the current operating system is a server operating system; otherwise, . - - - Gets a value indicating whether the current process is running under WOW64. - if the current process is running under WOW64; otherwise, . - - - Gets the numeric version of the operating system. - The numeric version of the operating system. - - - Gets the named version of the operating system. - The named version of the operating system. - - - Gets the processor architecture for which the operating system is targeted. - The processor architecture for which the operating system is targeted. - If running under WOW64 this will return a 32-bit processor. Use to determine if this is the case. - - - Gets the version of the service pack currently installed on the operating system. - The version of the service pack currently installed on the operating system. - Only the and fields are used. - - - Determines whether the operating system is of the specified version or later. - if the operating system is of the specified or later; otherwise, . - The lowest version for which to return true. - - - Determines whether the operating system is of the specified version or later, allowing specification of a minimum service pack that must be installed on the lowest version. - if the operating system matches the specified with the specified service pack, or if the operating system is of a later version; otherwise, . - The minimum required version. - The major version of the service pack that must be installed on the minimum required version to return true. This can be 0 to indicate that no service pack is required. - - - The RtlGetVersion routine returns version information about the currently running operating system. - RtlGetVersion returns STATUS_SUCCESS. - Available starting with Windows 2000. - - - Retrieves information about the current system to an application running under WOW64. - If the function is called from a 64-bit application, it is equivalent to the GetSystemInfo function. - - This function does not return a value. - To determine whether a Win32-based application is running under WOW64, call the function. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - Determines whether the specified process is running under WOW64. - - If the function succeeds, the return value is a nonzero value. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista, Windows XP with SP2 [desktop apps only] - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 [desktop apps only] - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Buffer is not large enough for the requested operation.. - - - - - Looks up a localized string similar to Cannot create directory.. - - - - - Looks up a localized string similar to Cannot determine Copy or Move action.. - - - - - Looks up a localized string similar to Destination buffer not large enough for the requested operation.. - - - - - Looks up a localized string similar to The device is not ready.. - - - - - Looks up a localized string similar to Incorrectly implemented function attempting to generate exception from successful operation. - . - - - - - Looks up a localized string similar to The specified file is hidden: [{0}]. - - - - - Looks up a localized string similar to The file or directory already exists.. - - - - - Looks up a localized string similar to The handle is closed.. - - - - - Looks up a localized string similar to The handle is invalid.. - - - - - Looks up a localized string similar to The handle is invalid. Win32Error: [{0}]. - - - - - Looks up a localized string similar to Creating hard-links on non-NTFS partitions is not supported.. - - - - - Looks up a localized string similar to Illegal characters: [{0}] in path.. - - - - - Looks up a localized string similar to An attempt to set an invalid file attribute failed.. - - - - - Looks up a localized string similar to Invalid stream name.. - - - - - Looks up a localized string similar to Invalid Subpath. - - - - - Looks up a localized string similar to Invalid transaction request.. - - - - - Looks up a localized string similar to Count cannot be negative.. - - - - - Looks up a localized string similar to Destination offset cannot be negative.. - - - - - Looks up a localized string similar to Length cannot be negative.. - - - - - Looks up a localized string similar to Lock length cannot be negative.. - - - - - Looks up a localized string similar to Offset cannot be negative.. - - - - - Looks up a localized string similar to This stream does not support seeking.. - - - - - Looks up a localized string similar to The file or directory is not a reparse point.. - - - - - Looks up a localized string similar to Argument is not a valid Volume GUID.. - - - - - Looks up a localized string similar to Path is a zero-length string or contains only white space.. - - - - - Looks up a localized string similar to Privilege name cannot be empty.. - - - - - Looks up a localized string similar to Incomplete header read.. - - - - - Looks up a localized string similar to This method requires Windows Vista or higher.. - - - - - Looks up a localized string similar to Invalid security descriptor returned from system.. - - - - - Looks up a localized string similar to Source offset and length outside the bounds of the array. - - - - - Looks up a localized string similar to The target directory is a file, not a directory: [{0}]. - - - - - Looks up a localized string similar to The target file is a directory, not a file: [{0}]. - - - - - Looks up a localized string similar to Transaction already aborted.. - - - - - Looks up a localized string similar to Transaction already committed.. - - - - - Looks up a localized string similar to Invalid transaction object.. - - - - - Looks up a localized string similar to Transaction not active.. - - - - - Looks up a localized string similar to Transaction not requested.. - - - - - Looks up a localized string similar to Transactional conflict.. - - - - - Looks up a localized string similar to Network share path should match the format: \\server\share. - - - - - Looks up a localized string similar to Backup FileStream Unlock Position must not be negative.. - - - - - Looks up a localized string similar to The given path's format is not supported: [{0}]. - - - - Represents a block of native memory of a specified size allocated using the LocalAlloc function from Kernel32.dll. - - - Creates new instance with zero IntPtr. - - - Initializes a new instance of the class allocating the specified number of bytes of unmanaged memory. - The capacity. - - - Called when object is disposed or finalized. - - - Base class for classes representing a block of unmanaged memory. - - - Initializes a new instance of the specifying the allocated capacity of the memory block. - The capacity. - - - Gets the capacity. Only valid if this instance was created using a constructor that specifies the size, - it is not correct if this handle was returned by a native method using p/invoke. - - - - Copies data from a one-dimensional, managed 8-bit unsigned integer array to the unmanaged memory pointer referenced by this instance. - The one-dimensional array to copy from. - The zero-based index into the array where Copy should start. - The number of array elements to copy. - - - Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array. - The array to copy to. - The zero-based index in the destination array where copying should start. - The number of array elements to copy. - - - Copies data from this unmanaged memory pointer to a managed 8-bit unsigned integer array. - The offset in the buffer to start copying from. - The array to copy to. - The zero-based index in the destination array where copying should start. - The number of array elements to copy. - - - Marshals data from a managed object to an unmanaged block of memory. - - - Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type. - A managed object containing the data pointed to by the ptr parameter. - - - Allocates a managed System.String and copies a specified number of characters from an unmanaged Unicode string into it. - A managed string that holds a copy of the unmanaged string if the value of the ptr parameter is not null; otherwise, this method returns null. - - - Allocates a managed System.String and copies all characters up to the first null character from an unmanaged Unicode string into it. - A managed string that holds a copy of the unmanaged string if the value of the ptr parameter is not null; otherwise, this method returns null. - - - Implements an ISO-3309 compliant 64-bit CRC hash algorithm. - - - Initializes a new instance of - - - Initializes a new instance of - The polynomial. - The seed. - - - - Initializes an implementation of the - class. - - - - When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash. - The input to compute the hash code for.. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream - object. - - - This method finalizes any partial computation and returns the correct hash value for the data - stream. - - - - Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. - - - Calculates the hash. - The seed. - The table. - The buffer. - The start. - The size. - The calculated hash. - - - Int 64 to big endian bytes. - The value. - A byte[]. - - - Initializes the table. - The polynomial. - An ulong[]. - - - Creates a table. - The polynomial. - A new array of ulong. - - - Enum containing the supported hash types. - - - CRC-32 (Cyclic Redundancy Check) - - - CRC-64 ISO-3309 compliant. - - - MD5 (Message digest) - - - RIPEMD-160 is a 160-bit cryptographic hash function. It is intended for use as a replacement for the 128-bit hash functions MD4, MD5, and RIPEMD. - - - SHA-1 (Secure Hash Algorithm) - - - SHA-256 (Secure Hash Algorithm) - - - SHA-384 (Secure Hash Algorithm) - - - SHA-512 (Secure Hash Algorithm) - - - The ObjectType (SE_OBJECT_TYPE) enumeration contains values that correspond to the types of Windows objects that support security. - The functions, such as GetSecurityInfo and SetSecurityInfo, that set and retrieve the security information of an object, use these values to indicate the type of object. - - - - Unknown object type. - - - Indicates a file or directory. The name string that identifies a file or directory object can be in one of the following formats: - A relative path, such as FileName.dat or ..\FileName - An absolute path, such as FileName.dat, C:\DirectoryName\FileName.dat, or G:\RemoteDirectoryName\FileName.dat. - A UNC name, such as \\ComputerName\ShareName\FileName.dat. - - - - Indicates a Windows service. A service object can be a local service, such as ServiceName, or a remote service, such as \\ComputerName\ServiceName. - - - Indicates a printer. A printer object can be a local printer, such as PrinterName, or a remote printer, such as \\ComputerName\PrinterName. - - - Indicates a registry key. A registry key object can be in the local registry, such as CLASSES_ROOT\SomePath or in a remote registry, such as \\ComputerName\CLASSES_ROOT\SomePath. - The names of registry keys must use the following literal strings to identify the predefined registry keys: "CLASSES_ROOT", "CURRENT_USER", "MACHINE", and "USERS". - - - - Indicates a network share. A share object can be local, such as ShareName, or remote, such as \\ComputerName\ShareName. - - - Indicates a local kernel object. The GetSecurityInfo and SetSecurityInfo functions support all types of kernel objects. - The GetNamedSecurityInfo and SetNamedSecurityInfo functions work only with the following kernel objects: semaphore, event, mutex, waitable timer, and file mapping. - - - Indicates a window station or desktop object on the local computer. You cannot use GetNamedSecurityInfo and SetNamedSecurityInfo with these objects because the names of window stations or desktops are not unique. - - - Indicates a directory service object or a property set or property of a directory service object. - The name string for a directory service object must be in X.500 form, for example: CN=SomeObject,OU=ou2,OU=ou1,DC=DomainName,DC=CompanyName,DC=com,O=internet - - - Indicates a directory service object and all of its property sets and properties. - - - Indicates a provider-defined object. - - - Indicates a WMI object. - - - Indicates an object for a registry entry under WOW64. - - - The SECURITY_DESCRIPTOR_CONTROL data type is a set of bit flags that qualify the meaning of a security descriptor or its components. - Each security descriptor has a Control member that stores the SECURITY_DESCRIPTOR_CONTROL bits. - - - - - - SE_OWNER_DEFAULTED (0x0001) - Indicates an SD with a default owner security identifier (SID). You can use this bit to find all of the objects that have default owner permissions set. - - - SE_GROUP_DEFAULTED (0x0002) - Indicates an SD with a default group SID. You can use this bit to find all of the objects that have default group permissions set. - - - SE_DACL_PRESENT (0x0004) - Indicates an SD that has a discretionary access control list (DACL). If this flag is not set, or if this flag is set and the DACL is NULL, the SD allows full access to everyone. - - - SE_DACL_DEFAULTED (0x0008) - Indicates an SD with a default DACL. For example, if an object creator does not specify a DACL, the object receives the default DACL from the access token of the creator. This flag can affect how the system treats the DACL, with respect to access control entry (ACE) inheritance. The system ignores this flag if the SE_DACL_PRESENT flag is not set. - - - SE_SACL_PRESENT (0x0010) - Indicates an SD that has a system access control list (SACL). - - - SE_SACL_DEFAULTED (0x0020) - Indicates an SD with a default SACL. For example, if an object creator does not specify an SACL, the object receives the default SACL from the access token of the creator. This flag can affect how the system treats the SACL, with respect to ACE inheritance. The system ignores this flag if the SE_SACL_PRESENT flag is not set. - - - SE_DACL_AUTO_INHERIT_REQ (0x0100) - Requests that the provider for the object protected by the SD automatically propagate the DACL to existing child objects. If the provider supports automatic inheritance, it propagates the DACL to any existing child objects, and sets the SE_DACL_AUTO_INHERITED bit in the security descriptors of the object and its child objects. - - - SE_SACL_AUTO_INHERIT_REQ (0x0200) - Requests that the provider for the object protected by the SD automatically propagate the SACL to existing child objects. If the provider supports automatic inheritance, it propagates the SACL to any existing child objects, and sets the SE_SACL_AUTO_INHERITED bit in the SDs of the object and its child objects. - - - SE_DACL_AUTO_INHERITED (0x0400) - Windows 2000 only. Indicates an SD in which the DACL is set up to support automatic propagation of inheritable ACEs to existing child objects. The system sets this bit when it performs the automatic inheritance algorithm for the object and its existing child objects. This bit is not set in SDs for Windows NT versions 4.0 and earlier, which do not support automatic propagation of inheritable ACEs. - - - SE_SACL_AUTO_INHERITED (0x0800) - Windows 2000: Indicates an SD in which the SACL is set up to support automatic propagation of inheritable ACEs to existing child objects. The system sets this bit when it performs the automatic inheritance algorithm for the object and its existing child objects. This bit is not set in SDs for Windows NT versions 4.0 and earlier, which do not support automatic propagation of inheritable ACEs. - - - SE_DACL_PROTECTED (0x1000) - Windows 2000: Prevents the DACL of the SD from being modified by inheritable ACEs. - - - SE_SACL_PROTECTED (0x2000) - Windows 2000: Prevents the SACL of the SD from being modified by inheritable ACEs. - - - SE_RM_CONTROL_VALID (0x4000) - Indicates that the resource manager control is valid. - - - SE_SELF_RELATIVE (0x8000) - Indicates an SD in self-relative format with all of the security information in a contiguous block of memory. If this flag is not set, the SD is in absolute format. For more information, see Absolute and Self-Relative Security Descriptors. - - - The SECURITY_INFORMATION data type identifies the object-related security information being set or queried. - This security information includes: - The owner of an object; - The primary group of an object; - The discretionary access control list (DACL) of an object; - The system access control list (SACL) of an object; - - - An unsigned 32-bit integer specifies portions of a SECURITY_DESCRIPTOR by means of bit flags. - Individual bit values (combinable with the bitwise OR operation) are as shown in the following table. - - - - - - - OWNER_SECURITY_INFORMATION (0x00000001) - The owner identifier of the object is being referenced. - - - GROUP_SECURITY_INFORMATION (0x00000002) - The primary group identifier of the object is being referenced. - - - DACL_SECURITY_INFORMATION (0x00000004) - The DACL of the object is being referenced. - - - SACL_SECURITY_INFORMATION (0x00000008) - The SACL of the object is being referenced. - - - LABEL_SECURITY_INFORMATION (0x00000010) - The mandatory integrity label is being referenced. The mandatory integrity label is an ACE in the SACL of the object. - Windows Server 2003 and Windows XP: This bit flag is not available. - - - ATTRIBUTE_SECURITY_INFORMATION (0x00000020) - The resource properties of the object being referenced. - The resource properties are stored in SYSTEM_RESOURCE_ATTRIBUTE_ACE types in the SACL of the security descriptor. - - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - SCOPE_SECURITY_INFORMATION (0x00000040) - The Central Access Policy (CAP) identifier applicable on the object that is being referenced. - Each CAP identifier is stored in a SYSTEM_SCOPED_POLICY_ID_ACE type in the SACL of the SD. - - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - BACKUP_SECURITY_INFORMATION (0x00010000) - All parts of the security descriptor. This is useful for backup and restore software that needs to preserve the entire security descriptor. - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - UNPROTECTED_SACL_SECURITY_INFORMATION (0x10000000) - The SACL inherits ACEs from the parent object. - - - UNPROTECTED_DACL_SECURITY_INFORMATION (0x20000000) - The DACL inherits ACEs from the parent object. - - - PROTECTED_SACL_SECURITY_INFORMATION (0x40000000) - The SACL cannot inherit ACEs. - - - PROTECTED_DACL_SECURITY_INFORMATION (0x80000000) - The DACL cannot inherit access control entries (ACEs). - - - An IntPtr wrapper which can be used as the result of a Marshal.AllocHGlobal operation. - Calls Marshal.FreeHGlobal when disposed or finalized. - - - - Creates new instance with zero IntPtr. - - - Copies data from a one-dimensional, managed 8-bit unsigned integer array to the unmanaged memory pointer referenced by this instance. - The one-dimensional array to copy from. - The zero-based index into the array where Copy should start. - The number of array elements to copy. - - - Called when object is disposed or finalized. - - - The AdjustTokenPrivileges function enables or disables privileges in the specified access token. Enabling or disabling privileges in an access token requires TOKEN_ADJUST_PRIVILEGES access. - - If the function succeeds, the return value is nonzero. - To determine whether the function adjusted all of the specified privileges, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The LookupPrivilegeDisplayName function retrieves the display name that represents a specified privilege. - - If the function succeeds, the return value is nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The LookupPrivilegeValue function retrieves the locally unique identifier (LUID) used on a specified system to locally represent the specified privilege name. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetNamedSecurityInfo function retrieves a copy of the security descriptor for an object specified by name. -   - - If the function succeeds, the return value is ERROR_SUCCESS. - If the function fails, the return value is a nonzero error code defined in WinError.h. - -   - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - The GetSecurityInfo function retrieves a copy of the security descriptor for an object specified by a handle. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The SetSecurityInfo function sets specified security information in the security descriptor of a specified object. - The caller identifies the object by a handle. - - If the function succeeds, the function returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The SetNamedSecurityInfo function sets specified security information in the security descriptor of a specified object. The caller identifies the object by name. -   - - If the function succeeds, the function returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. - -   - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - The GetSecurityDescriptorDacl function retrieves a pointer to the discretionary access control list (DACL) in a specified security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorSacl function retrieves a pointer to the system access control list (SACL) in a specified security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorGroup function retrieves the primary group information from a security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorControl function retrieves a security descriptor control and revision information. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorOwner function retrieves the owner information from a security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorLength function returns the length, in bytes, of a structurally valid security descriptor. The length includes the length of all associated structures. - - If the function succeeds, the function returns the length, in bytes, of the SECURITY_DESCRIPTOR structure. - If the SECURITY_DESCRIPTOR structure is not valid, the return value is undefined. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Frees the specified local memory object and invalidates its handle. - - If the function succeeds, the return value is . - If the function fails, the return value is equal to a handle to the local memory object. To get extended error information, call GetLastError. - - SetLastError is set to . - - Note The local functions have greater overhead and provide fewer features than other memory management functions. - New applications should use the heap functions unless documentation states that a local function should be used. - For more information, see Global and Local Functions. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Class used to represent the SECURITY_ATTRIBUES native Win32 structure. It provides initialization function from an object. - - - Marshals an ObjectSecurity instance to unmanaged memory. - A safe handle containing the marshalled security descriptor. - The security descriptor. - - - Implements a 32-bit CRC hash algorithm compatible with Zip etc. - - Crc32 should only be used for backward compatibility with older file formats - and algorithms. It is not secure enough for new applications. - If you need to call multiple times for the same data either use the HashAlgorithm - interface or remember that the result of one Compute call needs to be ~ (XOR) before - being passed in as the seed for the next Compute call. - - - - - Initializes a new instance of Crc32. - - - - Initializes a new instance of Crc32. - The polynomial. - The seed. - - - - Initializes an implementation of the - class. - - - - When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash. - The input to compute the hash code for.. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream - object. - - - This method finalizes any partial computation and returns the correct hash value for the data - stream. - - - - Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. - - - Initializes the table. - The polynomial. - The table. - - - Calculates the hash. - The table. - The seed. - The buffer. - The start. - The size. - The calculated hash. - - - Int 32 to big endian bytes. - The second uint 3. - A byte[]. - - - Represents a privilege for an access token. The privileges available on the local machine are available as - static instances from this class. To create a representing a privilege on another system, - use the constructor specifying a system name together with one of these static instances. - - - - - Required to assign the primary token of a process. User Right: Replace a process-level token. - - - Required to generate audit-log entries. Give this privilege to secure servers. User Right: Generate security audits. - - - Required to perform backup operations. This privilege causes the system to grant all read access control to any file, regardless of the access control list (ACL) specified for the file. Any access request other than read is still evaluated with the ACL. User Right: Back up files and directories. - - - Required to receive notifications of changes to files or directories. This privilege also causes the system to skip all traversal access checks. It is enabled by default for all users. User Right: Bypass traverse checking. - - - Required to create named file mapping objects in the global namespace during Terminal Services sessions. This privilege is enabled by default for administrators, services, and the local system account. User Right: Create global objects. - Windows XP/2000: This privilege is not supported. Note that this value is supported starting with Windows Server 2003, Windows XP SP2, and Windows 2000 SP4. - - - Required to create a paging file. User Right: Create a pagefile. - - - Required to create a permanent object. User Right: Create permanent shared objects. - - - Required to create a symbolic link. User Right: Create symbolic links. - - - Required to create a primary token. User Right: Create a token object. - - - Required to debug and adjust the memory of a process owned by another account. User Right: Debug programs. - - - Required to mark user and computer accounts as trusted for delegation. User Right: Enable computer and user accounts to be trusted for delegation. - - - Required to impersonate. User Right: Impersonate a client after authentication. - Windows XP/2000: This privilege is not supported. Note that this value is supported starting with Windows Server 2003, Windows XP SP2, and Windows 2000 SP4. - - - Required to increase the base priority of a process. User Right: Increase scheduling priority. - - - Required to increase the quota assigned to a process. User Right: Adjust memory quotas for a process. - - - Required to allocate more memory for applications that run in the context of users. User Right: Increase a process working set. - - - Required to load or unload a device driver. User Right: Load and unload device drivers. - - - Required to lock physical pages in memory. User Right: Lock pages in memory. - - - Required to create a computer account. User Right: Add workstations to domain. - - - Required to enable volume management privileges. User Right: Manage the files on a volume. - - - Required to gather profiling information for a single process. User Right: Profile single process. - - - Required to modify the mandatory integrity level of an object. User Right: Modify an object label. - - - Required to shut down a system using a network request. User Right: Force shutdown from a remote system. - - - Required to perform restore operations. This privilege causes the system to grant all write access control to any file, regardless of the ACL specified for the file. Any access request other than write is still evaluated with the ACL. Additionally, this privilege enables you to set any valid user or group SID as the owner of a file. User Right: Restore files and directories. - - - Required to perform a number of security-related functions, such as controlling and viewing audit messages. This privilege identifies its holder as a security operator. User Right: Manage auditing and security log. - - - Required to shut down a local system. User Right: Shut down the system. - - - Required for a domain controller to use the LDAP directory synchronization services. This privilege enables the holder to read all objects and properties in the directory, regardless of the protection on the objects and properties. By default, it is assigned to the Administrator and LocalSystem accounts on domain controllers. User Right: Synchronize directory service data. - - - Required to modify the nonvolatile RAM of systems that use this type of memory to store configuration information. User Right: Modify firmware environment values. - - - Required to gather profiling information for the entire system. User Right: Profile system performance. - - - Required to modify the system time. User Right: Change the system time. - - - Required to take ownership of an object without being granted discretionary access. This privilege allows the owner value to be set only to those values that the holder may legitimately assign as the owner of an object. User Right: Take ownership of files or other objects. - - - This privilege identifies its holder as part of the trusted computer base. Some trusted protected subsystems are granted this privilege. User Right: Act as part of the operating system. - - - Required to adjust the time zone associated with the computer's internal clock. User Right: Change the time zone. - - - Required to access Credential Manager as a trusted caller. User Right: Access Credential Manager as a trusted caller. - - - Required to undock a laptop. User Right: Remove computer from docking station. - - - Required to read unsolicited input from a terminal device. User Right: Not applicable. - - - Create a new representing the specified privilege on the specified system. - Name of the system. - The privilege to copy the privilege name from. - - - Gets the system name identifying this privilege. - The system name identifying this privilege. - - - Retrieves the display name that represents this privilege. - The display name that represents this privilege. - - - Retrieves the locally unique identifier (LUID) used on to represent this privilege (on the system from which it originates). - the locally unique identifier (LUID) used on to represent this privilege (on the system from which it originates). - - - Indicates whether the current object is equal to another object of the same type. - An object to compare with this object. - if the current object is equal to the parameter; otherwise, . - - - Determines whether the specified is equal to the current . - The to compare with the current . - if the specified is equal to the current ; otherwise, . - - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Returns the system name for this privilege. - This is equivalent to . - A that represents the current . - - - Initializes a new instance of the class, representing a privilege with the specified name on the local system. - The name. - - - Used to enable one or more privileges. The privileges specified will be enabled during the lifetime of the instance. Users create an instance of this object in a using statement to ensure that it is properly disposed when the elevated privileges are no longer needed. - - - Initializes a new instance of the class. - This will enable the privileges specified (unless already enabled), and ensure that they are disabled again when - the object is disposed. (Any privileges already enabled will not be disabled). - - The privilege to enable. - Additional privileges to enable. - - - Makes sure any privileges enabled by this instance are disabled. - - - Gets the enabled privileges. Note that this might not contain all privileges specified to the constructor. Only the privileges actually enabled by this instance is returned. - The enabled privileges. - - - - This object is used to enable a specific privilege for the currently running process during its lifetime. - It should be disposed as soon as the elevated privilege is no longer needed. - For more information see the documentation on AdjustTokenPrivileges on MSDN. - - - - Initializes a new instance of the class and enabling the specified privilege for the currently running process. - The name of the privilege. - - - - Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. - In this case the privilege previously enabled will be disabled. - - - - Adjusts the privilege. - the privilege will be enabled, otherwise disabled. - - - Use this to translate error codes into HRESULTs like 0x80070006 for ERROR_INVALID_HANDLE. - - - (0) The operation completed successfully. - - - (0) The operation completed successfully. - - - (1) Incorrect function. - - - (2) The system cannot find the file specified. - - - (3) The system cannot find the path specified. - - - (5) Access is denied. - - - (15) The system cannot find the drive specified. - - - (17) The system cannot move the file to a different disk drive. - - - (18) There are no more files. - - - (21) The device is not ready. - - - (25) The drive cannot locate a specific area or track on the disk. - - - (32) The process cannot access the file because it is being used by another process. - - - (33) The process cannot access the file because another process has locked a portion of the file. - - - (38) Reached the end of the file. - - - (53) The network path was not found. - - - (65) Network access is denied. - - - (67) The network name cannot be found. - - - (80) The file exists. - - - (87) The parameter is incorrect. - - - (122) The data area passed to a system call is too small. - - - (123) The filename, directory name, or volume label syntax is incorrect. - - - (143) The system cannot join or substitute a drive to or for a directory on the same drive. - - - (145) The directory is not empty. - - - (158) The segment is already unlocked. - - - (183) Cannot create a file when that file already exists. - - - (203) The system could not find the environment option that was entered. - - - (234) More data is available. - - - (267) The directory name is invalid. - - - (995) The I/O operation has been aborted because of either a thread exit or an application request. - - - (997) Overlapped I/O operation is in progress. - - - (1200) The specified device name is invalid. - - - (1208) An extended error has occurred. - - - (1222) The network is not present or not started. - - - (1235) The request was aborted. - - - (1641) The requested operation completed successfully. - The system will be restarted so the changes can take effect. - - - - (1783) The stub received bad data. - - - (3010) The requested operation is successful. - Changes will not be effective until the system is rebooted. - - - - (3011) The requested operation is successful. - Changes will not be effective until the service is restarted. - - - - (4390) The file or directory is not a reparse point. - - - (6009) The specified file is read only. - - - (6012) Recovery policy configured for this system contains invalid recovery certificate. - - - (6700) The transaction handle associated with this operation is not valid. - - - (6701) The requested operation was made in the context - of a transaction that is no longer active. - - - - (6702) The requested operation is not valid - on the Transaction object in its current state. - - - - (6703) The caller has called a response API, but the response is not expected - because the TM did not issue the corresponding request to the caller. - - - - (6704) It is too late to perform the requested operation, - since the Transaction has already been aborted. - - - - (6705) It is too late to perform the requested operation, - since the Transaction has already been committed. - - - - (6800) The function attempted to use a name - that is reserved for use by another transaction. - - - - (6805) The remote server or share does not support transacted file operations. - - - (0) The operation completed successfully. - - - (0) The operation completed successfully. - - - (2250) The network connection could not be found. - - - (2310) This shared resource does not exist. - - - (2314) There is not an open file with that identification number. - - - (0) The operation completed successfully. - - - Gets an attribute on an enum field value. - The description belonging to the enum option, as a string - One of the enum types. - - - Indicates whether a specified string is null, empty, or consists only of white-space characters. - if the parameter is null or , or if consists exclusively of white-space characters. - The string to test. - - - Converts a number of type T to string, suffixed with a unit size. - - - Calculates a percentage value. - - - - - - diff --git a/Bin/Debug/Net35/AlphaFS.dll b/Bin/Debug/Net35/AlphaFS.dll deleted file mode 100644 index ec222ca91d42a63209ec0f2b8852a4020d4a84c9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 312320 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

b}QC#9^3)AZ*S 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
2F#_$7G*x6+c`7=B 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 (chIeEYYQFS*6|0uT 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%0D(cmDJQDtTkw>_)tXxQ7ejA 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 U>-|Wm - - - - - - - - - Sign 'AlphaFS.dll' with a strong name key. - - - - - - - - - - - 'NativeError.ThrowException()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException()' ->'NativeError.ThrowException()' ->'BackupFileStream.ReadStreamInfo()' - - - - - - - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'DiskSpaceInfo.Refresh()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - 'NativeError.ThrowException(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string)' ->'NativeError.ThrowException(string)' ->'VolumeInfo.Refresh()' - - - - - - - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string, DosDeviceAttributes)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, DosDeviceAttributes, bool)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, bool)' - 'NativeError.ThrowException(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.SetVolumeLabel(string, string)' - - - - - - - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException()' ->'BackupFileStream.ReadStreamInfo()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Flush()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.GetAccessControl()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Lock(long, long)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Read(byte[], int, int, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Skip(long)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Unlock(long, long)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'BackupFileStream.Write(byte[], int, int, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Directory.GetCurrentDirectory()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.Dispose()' ->'PrivilegeEnabler.Dispose()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.InternalPrivilegeEnabler(Privilege)' ->'PrivilegeEnabler.PrivilegeEnabler(Privilege, params Privilege[])' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Privilege.LookupDisplayName()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int)' ->'Privilege.LookupLuid()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileInfo.Length.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileSystemInfo.Attributes.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileSystemInfo.CreationTimeUtc.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileSystemInfo.EntryInfo.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileSystemInfo.LastAccessTimeUtc.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'FileSystemInfo.LastWriteTimeUtc.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileIcon(string, Shell32.FileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfo(string, FileAttributes, Shell32.FileAttributes, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32Info.Attributes.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPoint(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Volume.GetVolumePathName(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string)' ->'Volume.SetVolumeMountPoint(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(int, string, string)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'DiskSpaceInfo.Refresh()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string)' ->'VolumeInfo.Refresh()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string, DosDeviceAttributes)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, DosDeviceAttributes, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, bool)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(string, string)' ->'Volume.SetVolumeLabel(string, string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string)' ->'FileInfo.Length.get()' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string)' ->'Volume.GetVolumeGuid(string)' - 'NativeError.ThrowException(uint, string, string)' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeError.ThrowException(uint, string, string)' ->'NativeError.ThrowException(uint, string, string)' ->'OpenResourceInfo.Close()' - - - - - - - - - - - - - 'OperatingSystem.IsWow64Process.get()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.IsWow64Process.get()' ->'OperatingSystem.IsWow64Process.get()' - 'OperatingSystem.IsWow64Process.get()' calls into 'Marshal.ThrowExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.ThrowExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.IsWow64Process.get()' ->'OperatingSystem.IsWow64Process.get()' - 'OperatingSystem.IsWow64Process.get()' calls into 'Process.GetCurrentProcess()' which has a LinkDemand. By making this call, 'Process.GetCurrentProcess()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.IsWow64Process.get()' ->'OperatingSystem.IsWow64Process.get()' - 'OperatingSystem.IsWow64Process.get()' calls into 'Process.Handle.get()' which has a LinkDemand. By making this call, 'Process.Handle.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.IsWow64Process.get()' ->'OperatingSystem.IsWow64Process.get()' - - - - - - - - - 'OperatingSystem.UpdateData()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.IsServer.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.OSVersion.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ProcessorArchitecture.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ServicePackVersion.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.VersionName.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.IsServer.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.OSVersion.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ProcessorArchitecture.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ServicePackVersion.get()' - 'OperatingSystem.UpdateData()' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'OperatingSystem.UpdateData()' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.VersionName.get()' - - - - - - - - - - - Review declarative security for 'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.IsServer.get()' - Review declarative security for 'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.OSVersion.get()' - Review declarative security for 'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ProcessorArchitecture.get()' - Review declarative security for 'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.ServicePackVersion.get()' - Review declarative security for 'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.GetNativeSystemInfo(ref OperatingSystem.NativeMethods.SYSTEM_INFO)' ->'OperatingSystem.UpdateData()' ->'OperatingSystem.VersionName.get()' - - - - - - - Review declarative security for 'OperatingSystem.NativeMethods.IsWow64Process(IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'OperatingSystem.NativeMethods.IsWow64Process(IntPtr, out bool)' ->'OperatingSystem.IsWow64Process.get()' - - - - - - - - - - - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Read(byte[], int, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.ReadStreamInfo()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Write(byte[], int, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedConnectionName(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedUncName(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'Marshal.AllocHGlobal(int)' which has a LinkDemand. By making this call, 'Marshal.AllocHGlobal(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Read(byte[], int, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.ReadStreamInfo()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Write(byte[], int, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedConnectionName(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedUncName(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeGlobalMemoryBufferHandle.FromLong(long?)' calls into 'Marshal.WriteInt64(IntPtr, long)' which has a LinkDemand. By making this call, 'Marshal.WriteInt64(IntPtr, long)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - - - - - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle()' ->'SafeGlobalMemoryBufferHandle.FromLong(long?)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Read(byte[], int, int, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.ReadStreamInfo()' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'BackupFileStream.Write(byte[], int, int, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedConnectionName(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedUncName(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(bool)' ->'SafeNativeMemoryBufferHandle.SafeNativeMemoryBufferHandle(int)' ->'SafeGlobalMemoryBufferHandle.SafeGlobalMemoryBufferHandle(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - - - - - - - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'BackupFileStream.Write(byte[], int, int, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' calls into 'Marshal.Copy(byte[], int, IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(byte[], int, IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyFrom(byte[], int, int)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - - - - - - - 'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' ->'BackupFileStream.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(byte[], int, int)' ->'BackupFileStream.Read(byte[], int, int, bool)' - - - - - - - 'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'SafeNativeMemoryBufferHandle.CopyTo(int, byte[], int, int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'SafeNativeMemoryBufferHandle.PtrToStringUni(int, int)' calls into 'Marshal.PtrToStringUni(IntPtr, int)' which has a LinkDemand. By making this call, 'Marshal.PtrToStringUni(IntPtr, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStringUni(int, int)' ->'SafeNativeMemoryBufferHandle.PtrToStringUni(int, int)' ->'BackupFileStream.ReadStreamInfo()' - - - - - - - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'BackupFileStream.ReadStreamInfo()' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string, string, string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsInfo(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedConnectionName(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedUncName(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(ShareInfoLevel, string, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(ShareInfoLevel, string, string, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(string, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(string, string, bool)' - 'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'SafeNativeMemoryBufferHandle.PtrToStructure<T>(int)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'ShareInfo.ResourceType.get()' - - - - - - - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' calls into 'Marshal.StructureToPtr(object, IntPtr, bool)' which has a LinkDemand. By making this call, 'Marshal.StructureToPtr(object, IntPtr, bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'SafeNativeMemoryBufferHandle.StructureToPtr(object, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'Marshal.Copy(IntPtr, byte[], int, int)' which has a LinkDemand. By making this call, 'Marshal.Copy(IntPtr, byte[], int, int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'SafeNativeMemoryBufferHandle.ToByteArray(int, int)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - - - - - - - - - - - - - - - 'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' - 'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' - 'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' ->'BackupFileStream.BackupFileStream(SafeFileHandle, FileSystemRights)' - - - - - - - 'BackupFileStream.Flush()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.Flush()' ->'BackupFileStream.Flush()' - - - - - - - 'BackupFileStream.GetAccessControl()' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.GetAccessControl()' ->'BackupFileStream.GetAccessControl()' - 'BackupFileStream.GetAccessControl()' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.GetAccessControl()' ->'BackupFileStream.GetAccessControl()' - - - - - - - 'BackupFileStream.Lock(long, long)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.Lock(long, long)' ->'BackupFileStream.Lock(long, long)' - - - - - - - 'BackupFileStream.ReadStreamInfo()' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.ReadStreamInfo()' ->'BackupFileStream.ReadStreamInfo()' - - - - - - - 'BackupFileStream.Skip(long)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.Skip(long)' ->'BackupFileStream.Skip(long)' - - - - - - - 'BackupFileStream.Unlock(long, long)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'BackupFileStream.Unlock(long, long)' ->'BackupFileStream.Unlock(long, long)' - - - - - - - - - - - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.OffsetOf(Type, string)' which has a LinkDemand. By making this call, 'Marshal.OffsetOf(Type, string)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.OffsetOf(Type, string)' which has a LinkDemand. By making this call, 'Marshal.OffsetOf(Type, string)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.OffsetOf(Type, string)' which has a LinkDemand. By making this call, 'Marshal.OffsetOf(Type, string)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'Marshal.OffsetOf(Type, string)' which has a LinkDemand. By making this call, 'Marshal.OffsetOf(Type, string)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'Device.GetLinkTargetInfoCore(SafeFileHandle)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - - - - - - - - - - - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - - - - - - - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - - - - - - - 'Directory.GetCurrentDirectory()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.GetCurrentDirectory()' ->'Directory.GetCurrentDirectory()' - - - - - - - 'Directory.SetCurrentDirectory(string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Directory.SetCurrentDirectory(string, PathFormat)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - - - - - - - - - - - 'DiskSpaceInfo.Refresh()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DiskSpaceInfo.Refresh()' ->'DiskSpaceInfo.Refresh()' - - - - - - - - - - - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - - - - - - - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - - - - - - - 'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - 'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - 'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - 'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - - - - - - - 'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - 'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - 'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - 'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - - - - - - - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - - - - - - - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - 'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - - - - - - - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - - - - - - - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - 'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - 'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - 'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'File.GetEncryptionStatusCore(string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - 'File.GetEncryptionStatusCore(string, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - - - - - - - 'File.GetFileInfoByHandle(SafeFileHandle)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetFileInfoByHandle(SafeFileHandle)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - - - - - - - 'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - 'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - - - - - - - 'File.IsLockedCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetHRForException(Exception)' which has a LinkDemand. By making this call, 'Marshal.GetHRForException(Exception)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'File.IsLockedCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetHRForException(Exception)' which has a LinkDemand. By making this call, 'Marshal.GetHRForException(Exception)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'File.IsLockedCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetHRForException(Exception)' which has a LinkDemand. By making this call, 'Marshal.GetHRForException(Exception)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'File.IsLockedCore(KernelTransaction, string, PathFormat)' calls into 'Marshal.GetHRForException(Exception)' which has a LinkDemand. By making this call, 'Marshal.GetHRForException(Exception)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - - - - - - - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' calls into 'SafeHandle.Dispose()' which has a LinkDemand. By making this call, 'SafeHandle.Dispose()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - - - - - - - 'File.ReplaceCore(string, string, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - 'File.ReplaceCore(string, string, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - 'File.ReplaceCore(string, string, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - 'File.ReplaceCore(string, string, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - 'File.ReplaceCore(string, string, string, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - - - - - - - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - 'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - - - - - - - - - - - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - 'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - - - - - - - - - - - 'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - - - - - - - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Commit()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.GetExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Rollback()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetHRForLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetHRForLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Commit()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetHRForLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetHRForLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Rollback()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Commit()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Rollback()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.ThrowExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.ThrowExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Commit()' - 'KernelTransaction.CheckTransaction()' calls into 'Marshal.ThrowExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.ThrowExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.CheckTransaction()' ->'KernelTransaction.Rollback()' - - - - - - - - - - - Review declarative security for 'NativeMethods.AssocCreate(Guid, ref Guid, out NativeMethods.IQueryAssociations)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocCreate(Guid, ref Guid, out NativeMethods.IQueryAssociations)' ->'Shell32Info.Initialize()' ->'Shell32Info.Refresh()' - Review declarative security for 'NativeMethods.AssocCreate(Guid, ref Guid, out NativeMethods.IQueryAssociations)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocCreate(Guid, ref Guid, out NativeMethods.IQueryAssociations)' ->'Shell32Info.Initialize()' ->'Shell32Info.Shell32Info(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileAssociation(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileContentType(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileDefaultIcon(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileFriendlyAppName(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileFriendlyDocName(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileOpenWithAppName(string)' - Review declarative security for 'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AssocQueryString(Shell32.AssociationAttributes, Shell32.AssociationString, string, string, StringBuilder, out uint)' ->'Shell32.GetFileAssociationCore(string, Shell32.AssociationAttributes, Shell32.AssociationString)' ->'Shell32.GetFileVerbCommand(string)' - - - - - - - Review declarative security for 'NativeMethods.BackupRead(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.BackupRead(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' ->'BackupFileStream.Read(byte[], int, int, bool)' - Review declarative security for 'NativeMethods.BackupRead(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.BackupRead(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' ->'BackupFileStream.ReadStreamInfo()' - - - - - - - Review declarative security for 'NativeMethods.BackupSeek(SafeFileHandle, uint, uint, out uint, out uint, ref IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.BackupSeek(SafeFileHandle, uint, uint, out uint, out uint, ref IntPtr)' ->'BackupFileStream.Skip(long)' - - - - - - - Review declarative security for 'NativeMethods.BackupWrite(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.BackupWrite(SafeFileHandle, SafeGlobalMemoryBufferHandle, uint, out uint, bool, bool, ref IntPtr)' ->'BackupFileStream.Write(byte[], int, int, bool)' - - - - - - - Review declarative security for 'NativeMethods.CommitTransaction(SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CommitTransaction(SafeHandle)' ->'KernelTransaction.Commit()' - - - - - - - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileEx(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CopyFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, out bool, CopyOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectory(string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - - - - - - - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryEx(string, string, NativeMethods.SecurityAttributes)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - - - - - - - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateDirectoryTransacted(string, string, NativeMethods.SecurityAttributes, SafeHandle)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - - - - - - - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFile(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - Review declarative security for 'NativeMethods.CreateFileMapping(SafeFileHandle, SafeHandle, uint, uint, uint, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileMapping(SafeFileHandle, SafeHandle, uint, uint, uint, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileMapping(SafeFileHandle, SafeHandle, uint, uint, uint, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileMapping(SafeFileHandle, SafeHandle, uint, uint, uint, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateFileTransacted(string, FileSystemRights, FileShare, NativeMethods.SecurityAttributes, FileMode, ExtendedFileAttributes, IntPtr, SafeHandle, IntPtr, IntPtr)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - Review declarative security for 'NativeMethods.CreateHardLink(string, string, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLink(string, string, IntPtr)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.CreateHardLink(string, string, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLink(string, string, IntPtr)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateHardLink(string, string, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLink(string, string, IntPtr)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateHardLink(string, string, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLink(string, string, IntPtr)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateHardLinkTransacted(string, string, IntPtr, SafeHandle)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLink(string, string, SymbolicLinkTarget)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateSymbolicLinkTransacted(string, string, SymbolicLinkTarget, SafeHandle)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.CreateTransaction(NativeMethods.SecurityAttributes, IntPtr, uint, uint, uint, int, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.CreateTransaction(NativeMethods.SecurityAttributes, IntPtr, uint, uint, uint, int, string)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - - - - - - - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.DecryptFile(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DecryptFile(string, uint)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - - - - - - - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string)' - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string, DosDeviceAttributes)' - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string)' - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string)' - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, DosDeviceAttributes, bool)' - Review declarative security for 'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DefineDosDevice(DosDeviceAttributes, string, string)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, bool)' - - - - - - - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.DeleteFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFile(string)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - - - - - - - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.DeleteFileTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteFileTransacted(string, SafeHandle)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - - - - - - - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.DeleteVolumeMountPoint(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeleteVolumeMountPoint(string)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPoint(string)' - - - - - - - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, IntPtr, uint, SafeGlobalMemoryBufferHandle, uint, out uint, IntPtr)' ->'Device.GetLinkTargetInfoCore(SafeFileHandle)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.DeviceIoControl(SafeFileHandle, uint, object, uint, object, uint, out uint, IntPtr)' ->'Device.InvokeIoControlUnknownSize<TV>(SafeFileHandle, uint, TV, uint)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - - - - - - - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.EncryptFile(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptFile(string)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - - - - - - - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - Review declarative security for 'NativeMethods.EncryptionDisable(string, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.EncryptionDisable(string, bool)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - - - - - - - Review declarative security for 'NativeMethods.FileEncryptionStatus(string, out FileEncryptionStatus)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FileEncryptionStatus(string, out FileEncryptionStatus)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - Review declarative security for 'NativeMethods.FileEncryptionStatus(string, out FileEncryptionStatus)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FileEncryptionStatus(string, out FileEncryptionStatus)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileEx(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - - - - - - - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FindFirstFileTransacted(string, NativeMethods.FINDEX_INFO_LEVELS, out NativeMethods.WIN32_FIND_DATA, NativeMethods.FINDEX_SEARCH_OPS, IntPtr, NativeMethods.FindExAdditionalFlags, SafeHandle)' ->'FindFileSystemEntryInfo.FindFirstFile(string, out NativeMethods.WIN32_FIND_DATA)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - - - - - - - Review declarative security for 'NativeMethods.FlushFileBuffers(SafeFileHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.FlushFileBuffers(SafeFileHandle)' ->'BackupFileStream.Flush()' - - - - - - - Review declarative security for 'NativeMethods.GetCompressedFileSize(string, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSize(string, out uint)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.GetCompressedFileSize(string, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSize(string, out uint)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetCompressedFileSize(string, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSize(string, out uint)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetCompressedFileSize(string, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSize(string, out uint)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCompressedFileSizeTransacted(string, out uint, SafeHandle)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.GetCurrentDirectory(uint, StringBuilder)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetCurrentDirectory(uint, StringBuilder)' ->'Directory.GetCurrentDirectory()' - - - - - - - Review declarative security for 'NativeMethods.GetDiskFreeSpace(string, out int, out int, out int, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetDiskFreeSpace(string, out int, out int, out int, out uint)' ->'DiskSpaceInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetDiskFreeSpaceEx(string, out long, out long, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetDiskFreeSpaceEx(string, out long, out long, out long)' ->'DiskSpaceInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetDriveType(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetDriveType(string)' ->'Volume.GetDriveType(string)' - - - - - - - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesEx(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileAttributesTransacted(string, NativeMethods.GetFileExInfoLevels, out NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, SafeHandle)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetFileInformationByHandle(SafeFileHandle, out NativeMethods.BY_HANDLE_FILE_INFORMATION)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandle(SafeFileHandle, out NativeMethods.BY_HANDLE_FILE_INFORMATION)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - - - - - - - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileInformationByHandleEx_FileBasicInfo(SafeFileHandle, NativeMethods.FileInfoByHandleClass, out NativeMethods.FILE_BASIC_INFO, uint)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFileSizeEx(SafeFileHandle, out long)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.GetFinalPathNameByHandle(SafeFileHandle, StringBuilder, uint, FinalPathFormats)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFinalPathNameByHandle(SafeFileHandle, StringBuilder, uint, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFinalPathNameByHandle(SafeFileHandle, StringBuilder, uint, FinalPathFormats)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFinalPathNameByHandle(SafeFileHandle, StringBuilder, uint, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathName(string, uint, StringBuilder, IntPtr)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - - - - - - - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetFullPathNameTransacted(string, uint, StringBuilder, IntPtr, SafeHandle)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - - - - - - - Review declarative security for 'NativeMethods.GetLongPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.GetLongPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetLongPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.GetLongPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - - - - - - - Review declarative security for 'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetLongPathNameTransacted(string, StringBuilder, uint, SafeHandle)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - - - - - - - Review declarative security for 'NativeMethods.GetMappedFileName(IntPtr, SafeLocalMemoryBufferHandle, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetMappedFileName(IntPtr, SafeLocalMemoryBufferHandle, StringBuilder, uint)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetMappedFileName(IntPtr, SafeLocalMemoryBufferHandle, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetMappedFileName(IntPtr, SafeLocalMemoryBufferHandle, StringBuilder, uint)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.GetShortPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetShortPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.GetShortPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetShortPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.GetShortPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetShortPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.GetShortPathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetShortPathName(string, StringBuilder, uint)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - - - - - - - Review declarative security for 'NativeMethods.GetVolumeInformation(string, StringBuilder, uint, out uint, out int, out NativeMethods.VolumeInfoAttributes, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetVolumeInformation(string, StringBuilder, uint, out uint, out int, out NativeMethods.VolumeInfoAttributes, StringBuilder, uint)' ->'VolumeInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetVolumeInformationByHandle(SafeFileHandle, StringBuilder, uint, out uint, out int, out NativeMethods.VolumeInfoAttributes, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetVolumeInformationByHandle(SafeFileHandle, StringBuilder, uint, out uint, out int, out NativeMethods.VolumeInfoAttributes, StringBuilder, uint)' ->'VolumeInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.GetVolumeNameForVolumeMountPoint(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetVolumeNameForVolumeMountPoint(string, StringBuilder, uint)' ->'Volume.GetVolumeGuid(string)' - - - - - - - Review declarative security for 'NativeMethods.GetVolumePathName(string, StringBuilder, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetVolumePathName(string, StringBuilder, uint)' ->'Volume.GetVolumePathName(string)' - - - - - - - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetFileInfoByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsClosed.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsClosed.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'NativeMethods.IsValidHandle(SafeHandle, int, bool)' calls into 'SafeHandle.IsInvalid.get()' which has a LinkDemand. By making this call, 'SafeHandle.IsInvalid.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'NativeMethods.IsValidHandle(SafeHandle, int, bool)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.LockFile(SafeFileHandle, uint, uint, uint, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.LockFile(SafeFileHandle, uint, uint, uint, uint)' ->'BackupFileStream.Lock(long, long)' - - - - - - - Review declarative security for 'NativeMethods.MapViewOfFile(SafeFileHandle, uint, uint, uint, UIntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MapViewOfFile(SafeFileHandle, uint, uint, uint, UIntPtr)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.MapViewOfFile(SafeFileHandle, uint, uint, uint, UIntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MapViewOfFile(SafeFileHandle, uint, uint, uint, UIntPtr)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileTransacted(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions, SafeHandle)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.MoveFileWithProgress(string, string, NativeMethods.NativeCopyMoveProgressRoutine, IntPtr, MoveOptions)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.OpenEncryptedFileRaw(string, NativeMethods.EncryptedFileRawMode, out SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.PathFileExists(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.PathFileExists(string)' ->'Shell32.PathFileExists(string)' - - - - - - - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReadEncryptedFileRaw(NativeMethods.EncryptedFileRawExportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.RemoveDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectory(string)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - - - - - - - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RemoveDirectoryTransacted(string, SafeHandle)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - - - - - - - Review declarative security for 'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - Review declarative security for 'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - Review declarative security for 'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ReplaceFile(string, string, string, FileSystemRights, IntPtr, IntPtr)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.RollbackTransaction(SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.RollbackTransaction(SafeHandle)' ->'KernelTransaction.Rollback()' - - - - - - - Review declarative security for 'NativeMethods.SetCurrentDirectory(string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetCurrentDirectory(string)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - - - - - - - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'DiskSpaceInfo.Refresh()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string, DosDeviceAttributes)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, DosDeviceAttributes, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, bool)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPoint(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetDriveType(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.SetVolumeLabel(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.SetVolumeMountPoint(string, string)' - Review declarative security for 'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetErrorMode(NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'VolumeInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributes(string, FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributes(string, FileAttributes)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - - - - - - - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileAttributesTransacted(string, FileAttributes, SafeHandle)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - - - - - - - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetFileTime(SafeFileHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle, SafeGlobalMemoryBufferHandle)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - - - - - - - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'DiskSpaceInfo.Refresh()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.Delete(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'File.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.DeleteFileCore(KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Delete(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Directory.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'DriveInfo.IsReady.get()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.Exists(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'File.ExistsTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.ExistsCore(bool, KernelTransaction, string, PathFormat)' ->'Volume.IsReady(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributes(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetAttributesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetCreationTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetCreationTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastAccessTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastAccessTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'Directory.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.GetLastWriteTimeCore(KernelTransaction, string, bool, PathFormat)' ->'File.GetLastWriteTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'File.GetAttributesExCore<T>(KernelTransaction, string, PathFormat, bool)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'File.FillAttributeInfoCore(KernelTransaction, string, ref NativeMethods.WIN32_FILE_ATTRIBUTE_DATA, bool, bool)' ->'FileSystemInfo.Refresh()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.GetFileSystemEntryInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'FindFileSystemEntryInfo.Get<T>()' ->'File.GetFileSystemEntryInfoCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileSystemInfo.RefreshEntryInfo()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.DisableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'Directory.EnableEncryption(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.DisableEncryption()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EnableDisableEncryptionCore(string, bool, PathFormat)' ->'DirectoryInfo.EnableEncryption()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Decrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'Directory.Encrypt(string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Decrypt(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.EncryptDecryptDirectoryCore(string, bool, bool, PathFormat)' ->'DirectoryInfo.Encrypt(bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRoot(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetDirectoryRootCore(KernelTransaction, string, PathFormat)' ->'Directory.GetDirectoryRootTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParent(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Directory.GetParentTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryName(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRoot(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetParentCore(KernelTransaction, string, PathFormat)' ->'Path.GetSuffixedDirectoryNameWithoutRootCore(KernelTransaction, string)' ->'Path.GetSuffixedDirectoryNameWithoutRootTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetProperties(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.GetPropertiesCore(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetPropertiesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Directory.SetCurrentDirectory(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlink(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateHardlinkCore(KernelTransaction, string, string, PathFormat)' ->'File.CreateHardlinkTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLink(string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.CreateSymbolicLinkCore(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' ->'File.CreateSymbolicLinkTransacted(KernelTransaction, string, string, SymbolicLinkTarget, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Decrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'File.Encrypt(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Decrypt()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.EncryptDecryptFileCore(bool, string, bool, PathFormat)' ->'FileInfo.Encrypt()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSize(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetCompressedSizeCore(KernelTransaction, string, PathFormat)' ->'File.GetCompressedSizeTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.GetEncryptionStatusCore(string, PathFormat)' ->'File.GetEncryptionStatus(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'File.Replace(string, string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.ReplaceCore(string, string, string, bool, PathFormat)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributes(string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'File.SetAttributesTransacted(KernelTransaction, string, FileAttributes, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'File.SetAttributesCore(bool, KernelTransaction, string, FileAttributes, bool, PathFormat)' ->'FileSystemInfo.Attributes.set(FileAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileInfo.Replace(string, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'DirectoryInfo.DirectoryInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FileSystemInfo.InitializeCore(bool, KernelTransaction, string, PathFormat)' ->'FileInfo.FileInfo(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjects(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.CountFileSystemObjectsTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectories(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateDirectoriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntries(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfos<T>(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosTransacted<T>(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFiles(string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.EnumerateFilesTransacted(KernelTransaction, string, string, SearchOption, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectories(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetDirectoriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntries(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFileSystemEntriesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFiles(string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'Directory.GetFilesTransacted(KernelTransaction, string, string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.CountFileSystemObjects(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, DirectoryEnumerationOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.EnumerateFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetDirectories(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFileSystemInfos(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles()' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'FindFileSystemEntryInfo.FindFileSystemEntryInfo(bool, KernelTransaction, string, string, DirectoryEnumerationOptions, Type, PathFormat)' ->'Directory.EnumerateFileSystemEntryInfosCore<T>(KernelTransaction, string, string, DirectoryEnumerationOptions, PathFormat)' ->'DirectoryInfo.GetFiles(string, SearchOption)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetExtendedLengthPathCore(KernelTransaction, string, PathFormat, GetFullPathOptions)' ->'Shell32Info.Shell32Info(string, PathFormat)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPath(string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTackleCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetFullPathTransacted(KernelTransaction, string, GetFullPathOptions)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPath(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetLongFrom83ShortPathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83Path(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.GetLongShort83PathCore(KernelTransaction, string, bool)' ->'Path.GetShort83PathTransacted(KernelTransaction, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Shell32.PathFileExists(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Path.GetFullPathCore(KernelTransaction, string, GetFullPathOptions)' ->'Volume.SetVolumeMountPoint(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DefineDosDevice(string, string, DosDeviceAttributes)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, DosDeviceAttributes, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DefineDosDeviceCore(bool, string, string, DosDeviceAttributes, bool)' ->'Volume.DeleteDosDevice(string, string, bool)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPoint(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetDriveType(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetVolumeGuid(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.GetVolumePathName(string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.SetVolumeLabel(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'Volume.SetVolumeMountPoint(string, string)' - Review declarative security for 'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetThreadErrorMode(NativeMethods.ErrorMode, out NativeMethods.ErrorMode)' ->'NativeMethods.ChangeErrorMode.ChangeErrorMode(NativeMethods.ErrorMode)' ->'VolumeInfo.Refresh()' - - - - - - - Review declarative security for 'NativeMethods.SetVolumeLabel(string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetVolumeLabel(string, string)' ->'Volume.SetCurrentVolumeLabel(string)' - Review declarative security for 'NativeMethods.SetVolumeLabel(string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetVolumeLabel(string, string)' ->'Volume.SetVolumeLabel(string, string)' - - - - - - - Review declarative security for 'NativeMethods.SetVolumeMountPoint(string, string)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetVolumeMountPoint(string, string)' ->'Volume.SetVolumeMountPoint(string, string)' - - - - - - - Review declarative security for 'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileIcon(string, Shell32.FileAttributes)' - Review declarative security for 'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfo(string, FileAttributes, Shell32.FileAttributes, bool)' - Review declarative security for 'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.ShGetFileInfo(string, FileAttributes, out Shell32.FileInfo, uint, Shell32.FileAttributes)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32Info.Attributes.get()' - - - - - - - Review declarative security for 'NativeMethods.UnlockFile(SafeFileHandle, uint, uint, uint, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.UnlockFile(SafeFileHandle, uint, uint, uint, uint)' ->'BackupFileStream.Unlock(long, long)' - - - - - - - Review declarative security for 'NativeMethods.UnmapViewOfFile(SafeLocalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.UnmapViewOfFile(SafeLocalMemoryBufferHandle)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - Review declarative security for 'NativeMethods.UnmapViewOfFile(SafeLocalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.UnmapViewOfFile(SafeLocalMemoryBufferHandle)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ExportEncryptedDirectoryRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'Directory.ImportEncryptedDirectoryRaw(Stream, string, bool, PathFormat)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ExportEncryptedFileRaw(string, Stream, PathFormat)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, PathFormat)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool)' - Review declarative security for 'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WriteEncryptedFileRaw(NativeMethods.EncryptedFileRawImportCallback, IntPtr, SafeEncryptedFileRawHandle)' ->'File.ImportExportEncryptedFileDirectoryRawCore(bool, bool, Stream, string, PathFormat, bool)' ->'File.ImportEncryptedFileRaw(Stream, string, bool, PathFormat)' - - - - - - - - - - - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.GetCurrentProcess()' which has a LinkDemand. By making this call, 'Process.GetCurrentProcess()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.GetCurrentProcess()' which has a LinkDemand. By making this call, 'Process.GetCurrentProcess()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.Handle.get()' which has a LinkDemand. By making this call, 'Process.Handle.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.Handle.get()' which has a LinkDemand. By making this call, 'Process.Handle.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - 'Path.NormalizePath(string, GetFullPathOptions)' has 71 local variables, 47 of which were generated by the compiler. Refactor 'Path.NormalizePath(string, GetFullPathOptions)' so that it uses fewer than 64 local variables. - - - - - - - - - - - 'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' ->'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' - 'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' ->'SafeFindFileHandle.SafeFindFileHandle(IntPtr, bool)' - - - - - - - - - - - 'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' calls into 'SafeHandle.SetHandle(IntPtr)' which has a LinkDemand. By making this call, 'SafeHandle.SetHandle(IntPtr)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' ->'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' - 'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' calls into 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' which has a LinkDemand. By making this call, 'SafeHandleZeroOrMinusOneIsInvalid.SafeHandleZeroOrMinusOneIsInvalid(bool)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' ->'SafeFindVolumeHandle.SafeFindVolumeHandle(IntPtr, bool)' - - - - - - - - - - - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileIcon(string, Shell32.FileAttributes)' - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfo(string, FileAttributes, Shell32.FileAttributes, bool)' - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32Info.Attributes.get()' - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileIcon(string, Shell32.FileAttributes)' - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfo(string, FileAttributes, Shell32.FileAttributes, bool)' - 'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32.GetFileInfoCore(string, FileAttributes, Shell32.FileAttributes, bool, bool)' ->'Shell32Info.Attributes.get()' - - - - - - - - - - - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.Delete(string, bool, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectories(string, bool, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories()' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteEmptySubdirectoriesCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, PathFormat)' ->'DirectoryInfo.DeleteEmptySubdirectories(bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'Directory.DeleteTransacted(KernelTransaction, string, bool, bool, PathFormat)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete()' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Directory.DeleteDirectoryCore(FileSystemEntryInfo, KernelTransaction, string, bool, bool, bool, bool, PathFormat)' ->'DirectoryInfo.Delete(bool, bool)' - 'Volume.DeleteVolumeMountPointCore(string, bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPointCore(string, bool)' ->'Volume.DeleteVolumeMountPoint(string)' - - - - - - - 'Volume.GetVolumeGuid(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.GetVolumeGuid(string)' ->'Volume.GetVolumeGuid(string)' - - - - - - - 'Volume.GetVolumePathName(string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.GetVolumePathName(string)' ->'Volume.GetVolumePathName(string)' - - - - - - - 'Volume.SetCurrentVolumeLabel(string)' calls into 'Marshal.GetHRForLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetHRForLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.SetCurrentVolumeLabel(string)' ->'Volume.SetCurrentVolumeLabel(string)' - 'Volume.SetCurrentVolumeLabel(string)' calls into 'Marshal.ThrowExceptionForHR(int)' which has a LinkDemand. By making this call, 'Marshal.ThrowExceptionForHR(int)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.SetCurrentVolumeLabel(string)' ->'Volume.SetCurrentVolumeLabel(string)' - - - - - - - 'Volume.SetVolumeMountPoint(string, string)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Volume.SetVolumeMountPoint(string, string)' ->'Volume.SetVolumeMountPoint(string, string)' - - - - - - - - - - - 'VolumeInfo.Refresh()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'VolumeInfo.Refresh()' ->'VolumeInfo.Refresh()' - - - - - - - - - - - - - - - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string)' - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string, string, string)' - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.PtrToStructure(IntPtr, Type)' which has a LinkDemand. By making this call, 'Marshal.PtrToStructure(IntPtr, Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsInfo(string)' - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string)' - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string, string, string)' - 'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' calls into 'Marshal.SizeOf(Type)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(Type)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'DfsInfo.DfsInfo(NativeMethods.DFS_INFO_9)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsInfo(string)' - - - - - - - - - - - Review declarative security for 'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string)' - Review declarative security for 'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string, string, string)' - Review declarative security for 'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetClientInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsInfo(string)' - - - - - - - Review declarative security for 'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string)' - Review declarative security for 'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsClientInfo(string, string, string)' - Review declarative security for 'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetDfsGetInfo(string, string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetDfsInfoCore(bool, string, string, string)' ->'Host.GetDfsInfo(string)' - - - - - - - Review declarative security for 'NativeMethods.NetFileClose(string, uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetFileClose(string, uint)' ->'OpenResourceInfo.Close()' - - - - - - - Review declarative security for 'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(ShareInfoLevel, string, bool)' - Review declarative security for 'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(ShareInfoLevel, string, string, bool)' - Review declarative security for 'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(string, bool)' - Review declarative security for 'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'Host.GetShareInfo(string, string, bool)' - Review declarative security for 'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.NetShareGetInfo(string, string, uint, out SafeGlobalMemoryBufferHandle)' ->'Host.GetShareInfoCore(ShareInfoLevel, string, string, bool)' ->'ShareInfo.ResourceType.get()' - - - - - - - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.Dispose(bool)' ->'DriveConnection.Dispose()' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.Dispose(bool)' ->'DriveConnection.~DriveConnection()' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string, NetworkCredential, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string, string, string, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(IntPtr, string, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(IntPtr, string, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(IntPtr, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(IntPtr, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectDrive(string)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectDrive(string, bool, bool)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectFrom(string)' - Review declarative security for 'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetCancelConnection(string, NativeMethods.Connect, bool)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectFrom(string, bool, bool)' - - - - - - - Review declarative security for 'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedConnectionName(string)' - Review declarative security for 'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.GetMappedUncName(string)' - Review declarative security for 'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string)' - Review declarative security for 'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool)' - Review declarative security for 'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetGetUniversalName(string, uint, SafeGlobalMemoryBufferHandle, out uint)' ->'Host.GetRemoteNameInfoCore(string, bool)' ->'Path.LocalToUncCore(string, bool, bool, bool)' ->'Path.LocalToUnc(string, bool, bool, bool)' - - - - - - - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.Dispose(bool)' ->'DriveConnection.Dispose()' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.Dispose(bool)' ->'DriveConnection.~DriveConnection()' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string, NetworkCredential, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'DriveConnection.DriveConnection(string, string, string, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(IntPtr, string, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(IntPtr, string, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectDrive(string, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(IntPtr, string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(IntPtr, string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string, NetworkCredential, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.ConnectTo(string, string, string, bool, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectDrive(string)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectDrive(string, bool, bool)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectFrom(string)' - Review declarative security for 'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.WNetUseConnection(IntPtr, ref NativeMethods.NETRESOURCE, string, string, NativeMethods.Connect, StringBuilder, out uint, out uint)' ->'Host.ConnectDisconnectCore(Host.ConnectDisconnectArguments)' ->'Host.DisconnectFrom(string, bool, bool)' - - - - - - - - - - - - - - - 'InternalPrivilegeEnabler.AdjustPrivilege(bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.Dispose()' ->'PrivilegeEnabler.Dispose()' - 'InternalPrivilegeEnabler.AdjustPrivilege(bool)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.InternalPrivilegeEnabler(Privilege)' ->'PrivilegeEnabler.PrivilegeEnabler(Privilege, params Privilege[])' - 'InternalPrivilegeEnabler.AdjustPrivilege(bool)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.Dispose()' ->'PrivilegeEnabler.Dispose()' - 'InternalPrivilegeEnabler.AdjustPrivilege(bool)' calls into 'Marshal.SizeOf(object)' which has a LinkDemand. By making this call, 'Marshal.SizeOf(object)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.InternalPrivilegeEnabler(Privilege)' ->'PrivilegeEnabler.PrivilegeEnabler(Privilege, params Privilege[])' - - - - - - - - - - - Review declarative security for 'NativeMethods.AdjustTokenPrivileges(IntPtr, bool, ref TokenPrivileges, uint, out TokenPrivileges, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AdjustTokenPrivileges(IntPtr, bool, ref TokenPrivileges, uint, out TokenPrivileges, out uint)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.Dispose()' ->'PrivilegeEnabler.Dispose()' - Review declarative security for 'NativeMethods.AdjustTokenPrivileges(IntPtr, bool, ref TokenPrivileges, uint, out TokenPrivileges, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.AdjustTokenPrivileges(IntPtr, bool, ref TokenPrivileges, uint, out TokenPrivileges, out uint)' ->'InternalPrivilegeEnabler.AdjustPrivilege(bool)' ->'InternalPrivilegeEnabler.InternalPrivilegeEnabler(Privilege)' ->'PrivilegeEnabler.PrivilegeEnabler(Privilege, params Privilege[])' - - - - - - - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetNamedSecurityInfo(string, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorControl(SafeGlobalMemoryBufferHandle, out SecurityDescriptorControl, out uint)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorDacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorGroup(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'BackupFileStream.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorLength(SafeGlobalMemoryBufferHandle)' ->'File.GetSecurityDescriptor<T>(uint, bool, string, SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorOwner(SafeGlobalMemoryBufferHandle, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityDescriptorSacl(SafeGlobalMemoryBufferHandle, out bool, out IntPtr, out bool)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'BackupFileStream.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'Directory.GetAccessControl(SafeFileHandle, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControl(SafeFileHandle, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - Review declarative security for 'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.GetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, out IntPtr, out IntPtr, out IntPtr, out IntPtr, out SafeGlobalMemoryBufferHandle)' ->'File.GetAccessControlHandleCore<T>(bool, bool, SafeFileHandle, AccessControlSections, SecurityInformation)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.LookupPrivilegeDisplayName(string, string, ref StringBuilder, ref uint, out uint)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.LookupPrivilegeDisplayName(string, string, ref StringBuilder, ref uint, out uint)' ->'Privilege.LookupDisplayName()' - - - - - - - Review declarative security for 'NativeMethods.LookupPrivilegeValue(string, string, out Luid)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.LookupPrivilegeValue(string, string, out Luid)' ->'Privilege.LookupLuid()' - - - - - - - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetNamedSecurityInfo(string, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'BackupFileStream.SetAccessControl(ObjectSecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(SafeFileHandle, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'Directory.SetAccessControl(string, DirectorySecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'DirectoryInfo.SetAccessControl(DirectorySecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(SafeFileHandle, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, AccessControlSections, PathFormat)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'File.SetAccessControl(string, FileSecurity, PathFormat)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity)' - Review declarative security for 'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: ->'NativeMethods.SetSecurityInfo(SafeHandle, ObjectType, SecurityInformation, IntPtr, IntPtr, IntPtr, IntPtr)' ->'File.SetAccessControlCore(string, SafeFileHandle, ObjectSecurity, AccessControlSections, PathFormat)' ->'FileInfo.SetAccessControl(FileSecurity, AccessControlSections)' - - - - - - - - - - - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Copy(string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.Move(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'Directory.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.CopyTo(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CopyMoveCore(KernelTransaction, string, string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'DirectoryInfo.CopyToMoveToCore(string, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'DirectoryInfo.MoveTo(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, DirectorySecurity, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, DirectorySecurity, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectory(string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, DirectorySecurity, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, DirectorySecurity, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'Directory.CreateDirectoryTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.Create(bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, DirectorySecurity, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'Directory.CreateDirectoryCore(KernelTransaction, string, string, ObjectSecurity, bool, PathFormat)' ->'DirectoryInfo.CreateSubdirectoryCore(string, string, DirectorySecurity, bool)' ->'DirectoryInfo.CreateSubdirectory(string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'BackupFileStream.BackupFileStream(string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Compress(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, DirectoryEnumerationOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.Decompress(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, DirectoryEnumerationOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'Directory.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Compress(DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.CompressDecompressCore(KernelTransaction, string, string, DirectoryEnumerationOptions, bool, PathFormat)' ->'DirectoryInfo.Decompress(DirectoryEnumerationOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompression(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.DisableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompression(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'Directory.EnableCompressionTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.DisableCompression()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'DirectoryInfo.EnableCompression()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Compress(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.CompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.Decompress(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'File.DecompressTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Compress()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'Device.ToggleCompressionCore(bool, KernelTransaction, string, bool, PathFormat)' ->'FileInfo.Decompress()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, CopyOptions, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Copy(string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, CopyOptions, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.CopyTransacted(KernelTransaction, string, string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.Move(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'File.MoveTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, CopyOptions, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.CopyTo(string, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, CopyMoveProgressRoutine, object, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, MoveOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CopyMoveCore(bool, KernelTransaction, string, string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, CopyMoveResult, PathFormat)' ->'FileInfo.CopyToMoveToCore(string, bool, CopyOptions?, MoveOptions?, CopyMoveProgressRoutine, object, out string, PathFormat)' ->'FileInfo.MoveTo(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.Create(string, int, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateText(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.CreateTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'File.CreateTransacted(KernelTransaction, string, int, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.Create()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.CreateFileStreamCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileAccess, FileShare, int, PathFormat)' ->'FileInfo.CreateText()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.GetAccessControl(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'Directory.HasInheritedPermissions(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'DirectoryInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, AccessControlSections, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'File.GetAccessControl(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetAccessControlCore<T>(bool, string, AccessControlSections, PathFormat)' ->'FileInfo.GetAccessControl(AccessControlSections)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(SafeFileHandle)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTime(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'Directory.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(SafeFileHandle)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTime(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(SafeFileHandle)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtc(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetChangeTimeCore(bool, KernelTransaction, SafeFileHandle, string, bool, PathFormat)' ->'File.GetChangeTimeUtcTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfo(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetLinkTargetInfoCore(KernelTransaction, string, PathFormat)' ->'File.GetLinkTargetInfoTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(SafeFileHandle)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSize(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.GetSizeCore(KernelTransaction, SafeFileHandle, string, PathFormat)' ->'File.GetSizeTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupRead(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenBackupReadTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendText(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.AppendTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.AppendTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'FileInfo.AppendText(Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(KernelTransaction, string, HashType, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'File.GetHash(string, HashType, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.GetHashCore(KernelTransaction, string, HashType, PathFormat)' ->'FileInfo.GetHash(HashType)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLocked(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.IsLockedCore(KernelTransaction, string, PathFormat)' ->'File.IsLockedTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, FileAccess, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.Open(string, FileMode, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, FileShare, int, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileAccess, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllText(string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.ReadAllTextCore(KernelTransaction, string, Encoding, PathFormat)' ->'File.ReadAllTextTransacted(KernelTransaction, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[])' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytes(string, byte[], PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[])' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAllBytesCore(KernelTransaction, string, byte[], PathFormat)' ->'File.WriteAllBytesTransacted(KernelTransaction, string, byte[], PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileAccess, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenRead()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenText(Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileAccess, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.OpenWrite()' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, ExtendedFileAttributes, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, FileSecurity, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.OpenTransacted(KernelTransaction, string, FileMode, FileSystemRights, FileShare, int, FileOptions, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllText(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.AppendAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, IEnumerable<string>, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[])' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLines(string, string[], PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, IEnumerable<string>, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[])' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllLinesTransacted(KernelTransaction, string, string[], PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllText(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, Encoding, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'File.WriteAppendAllLinesCore(KernelTransaction, string, IEnumerable<string>, Encoding, bool, bool, PathFormat)' ->'File.WriteAllTextTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.OpenCore(KernelTransaction, string, FileMode, FileSystemRights, FileShare, ExtendedFileAttributes, int?, FileSecurity, PathFormat)' ->'FileInfo.Open(FileMode, FileSystemRights, FileShare)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'Directory.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetCreationTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastAccessTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTime(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtc(string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetLastWriteTimeUtcTransacted(KernelTransaction, string, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestamps(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtc(string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.SetTimestampsUtcTransacted(KernelTransaction, string, DateTime, DateTime, DateTime, bool, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestamps(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'Directory.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestamps(string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'File.TransferTimestampsCore(bool, KernelTransaction, string, string, PathFormat)' ->'File.TransferTimestampsTransacted(KernelTransaction, string, string, PathFormat)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.CreationTimeUtc.set(DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastAccessTimeUtc.set(DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'File.CreateFileCore(KernelTransaction, string, ExtendedFileAttributes, FileSecurity, FileMode, FileSystemRights, FileShare, bool, PathFormat)' ->'File.SetFsoDateTimeCore(bool, KernelTransaction, string, DateTime?, DateTime?, DateTime?, bool, PathFormat)' ->'FileSystemInfo.LastWriteTimeUtc.set(DateTime)' - 'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' calls into 'SafeHandle.Close()' which has a LinkDemand. By making this call, 'SafeHandle.Close()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.ToUnmanagedSecurityAttributes(ObjectSecurity)' ->'NativeMethods.SecurityAttributes.SecurityAttributes(ObjectSecurity)' ->'KernelTransaction.KernelTransaction(ObjectSecurity, int, string)' - - - - - - - - - - - 'Privilege.LookupDisplayName()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Privilege.LookupDisplayName()' ->'Privilege.LookupDisplayName()' - - - - - - - 'Privilege.LookupLuid()' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Privilege.LookupLuid()' ->'Privilege.LookupLuid()' - - - - - - - - - - - - - - - Assemblies should have valid strong names - Either the assembly has no strong name, an invalid one, or the strong name is valid only because of the computer configuration. The assembly should not be deployed in this state. The most common causes of this are: 1) The assembly's contents were modified after it was signed. 2) The signing process failed. 3) The assembly was delay-signed. 4) A registry key existed that allowed the check to pass (where it would not have otherwise). - Sign {0} with a strong name key. - - http://msdn.microsoft.com/library/ms182127.aspx - [none] - CriticalError - - - - Avoid excessive locals - Method implementations should not contain more than 64 local variables. In order for the run-time to enregister local variables most efficiently, there should be 64 or fewer of them. Enregistering based on flow analysis will not occur for locals in excess of 64, which may result in slower performance. - {0} has {1} local variables, {2} of which were generated by the compiler. Refactor {0} so that it uses fewer than 64 local variables. - - http://msdn.microsoft.com/library/ms182263.aspx - [none] - Warning - - - - Do not indirectly expose methods with link demands - Do not wrap a method protected by a LinkDemand with a method that does not perform a security check. A LinkDemand checks the permissions of the immediate caller rather than checking the permissions of all callers in the call stack. In this case, the permissions of the wrapper method will be checked. If the wrapper method does not, itself, check the permissions of callers higher in the call stack, malicious code might be able to execute the wrapped function even though it lacks permission to do so. - {0} calls into {1} which has a LinkDemand. By making this call, {1} is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: {2} - - http://msdn.microsoft.com/library/ms182303.aspx - [none] - CriticalError - - - - Review SuppressUnmanagedCodeSecurityAttribute usage - Calling a method with the SuppressUnmanagedCodeSecurityAttribute applied to it can create a security weakness. Unmanaged code security checks ensure that all callers in the call stack have permission to execute unmanaged code. Disabling code security for P/Invoke methods allows callers that do not have this permission to breach security. This is acceptable only if the code is completely harmless, or callers have no way to pass arbitrary arguments through to the unmanaged code. - Review declarative security for {0} and its callers for potential vulnerabilities. The following call stack might expose a way to circumvent security protection: {1} - - http://msdn.microsoft.com/library/ms182311.aspx - [none] - CriticalError - - - - - Category - Certainty - Collapse All - Check Id - Error - error(s) - Expand All - Help - Line - message(s) - [Location not stored in Pdb] - Project - Resolution - Rule - Rule File - Rule Description - Source - Status - Target - Warning - warning(s) - Code Analysis Report - - diff --git a/Bin/Debug/Net35/AlphaFS.dll.config b/Bin/Debug/Net35/AlphaFS.dll.config deleted file mode 100644 index bd4cf43..0000000 --- a/Bin/Debug/Net35/AlphaFS.dll.config +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/Bin/Debug/Net35/AlphaFS.dll.lastcodeanalysissucceeded b/Bin/Debug/Net35/AlphaFS.dll.lastcodeanalysissucceeded deleted file mode 100644 index e69de29..0000000 diff --git a/Bin/Debug/Net35/AlphaFS.pdb b/Bin/Debug/Net35/AlphaFS.pdb deleted file mode 100644 index 6758b597a2f28bc5108b8821e8ebaf63adb92374..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 947712 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 - - - AlphaFS - - - -

Information about an alternate data stream. - - - - Gets the name of the alternate data stream. - This value is an empty string for the default stream (:$DATA), and for any other data stream it contains the name of the stream. - The name of the stream. - - - Gets the size of the stream. - - - Gets the full path to the stream. - - This is a path in long path format that can be passed to to open the stream if - or - is specified. - - The full path to the stream in long path format. - - - Returns the hash code for this instance. - A 32-bit signed integer that is the hash code for this instance. - - - Indicates whether this instance and a specified object are equal. - The object to compare with the current instance. - - true if and this instance are the same type and represent the same value; otherwise, false. - - - - Equality operator. - The first operand. - The second operand. - The result of the operation. - - - Inequality operator. - The first operand. - The second operand. - The result of the operation. - - - The structure contains stream header data. - - - - Initializes a new instance of the class. - The stream ID. - The name. - - - Gets the size of the data in the substream, in bytes. - The size of the data in the substream, in bytes. - - - Gets a string that specifies the name of the alternative data stream. - A string that specifies the name of the alternative data stream. - - - Gets the type of the data in the stream. - The type of the data in the stream. - - - Gets the attributes of the data to facilitate cross-operating system transfer. - Attributes of the data to facilitate cross-operating system transfer. - - - Callback used by CopyFileXxx and MoveFileXxx to report progress about the copy/move operation. - - - Exposes static methods for creating, moving, and enumerating through directories and subdirectories. - This class cannot be inherited. - - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is not allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing directory to a new directory. Overwriting a directory of the same name is allowed. - - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - if the destination directory should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - - - [AlphaFS] Moves a file or a directory and its contents to a new location. - - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a file or a directory and its contents to a new location, can be specified, - and the possibility of notifying the application of its progress through a callback function. - A class with the status of the Move action. - - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move a Non-/Transacted file or directory including its children to a new location, - or can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless contains . - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an IOException. - - - A class with the status of the Copy or Move action. - - - - - - - The transaction. - The source directory path. - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied/moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - The transaction. - The directory path. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Deletes empty subdirectories from the specified directory. - - - - The transaction. - The name of the directory to remove empty subdirectories from. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - Indicates the format of the path parameter(s). - - - Delete empty subdirectories from the specified directory. - - - - - - - A FileSystemEntryInfo instance. Use either or , not both. - The transaction. - The name of the directory to remove empty subdirectories from. Use either or , not both. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - When indicates the method is called externally. - Indicates the format of the path parameter(s). - - - Deletes an empty directory from a specified path. - - - - - - - - The name of the empty directory to remove. This directory must be writable and empty. - - - Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The name of the empty directory to remove. This directory must be writable and empty. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The transaction. - The name of the empty directory to remove. This directory must be writable and empty. - - - [AlphaFS] Deletes an empty directory from a specified path. - - - - - - - - The transaction. - The name of the empty directory to remove. This directory must be writable and empty. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - - - [AlphaFS] Deletes the specified directory and, if indicated, any subdirectories in the directory. - - - - - - - - The transaction. - The name of the directory to remove. - to remove directories, subdirectories, and files in . otherwise. - overrides read only of files and directories. - Indicates the format of the path parameter(s). - - - Deletes the specified directory and, if indicated, any subdirectories in the directory. - The RemoveDirectory function marks a directory for deletion on close. Therefore, the directory is not removed until the last handle to the directory is closed. - - - - - - - - A FileSystemEntryInfo instance. Use either or , not both. - The transaction. - The name of the directory to remove. Use either or , not both. - to remove all files and subdirectories recursively; otherwise only the top level empty directory. - overrides read only attribute of files and directories. - requires the directory must be empty. - does not throw an Exception when the file system object does not exist. - Indicates the format of the path parameter(s). - - - Creates all directories and subdirectories in the specified path unless they already exist. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all the directories in the specified path, unless the already exist, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all directories and subdirectories in the specified path unless they already exist. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates all the directories in the specified path, unless the already exist, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path, applying the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - - - [AlphaFS] Creates a new directory, with the attributes of a specified template directory. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - - - [AlphaFS] Creates all the directories in the specified path of a specified template directory and applies the specified Windows security. - An object that represents the directory at the specified path. This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. - The access control to apply to the directory. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Creates a new directory with the attributes of a specified template directory (if one is specified). - If the underlying file system supports security on files and directories, the function applies the specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - Returns an object that represents the directory at the specified path. - This object is returned regardless of whether a directory at the specified path already exists. - - - - - - - - The transaction. - The directory to create. - The path of the directory to use as a template when creating the new directory. May be to indicate that no template should be used. - The access control to apply to the directory, may be null. - When compresses the directory. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of directory names that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory names in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory instances in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of directory instances that match a in a specified . - An enumerable collection of the full names (including paths) for the directories in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file instances instances that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances instances that match a in a specified , and optionally searches subdirectories. - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file instances that match a in a specified . - An enumerable collection of the full names (including paths) for the files in the directory specified by and that match the . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path. - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system entries that match a in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file system entries in a specified path using . - The matching file system entries. The type of the items is determined by the type . - - - - - - - The type to return. This may be one of the following types: - - - - This method will return instances of instances. - - - - This method will return instances of and instances. - - - - This method will return the full path of each item. - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - - - Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified , and optionally searches subdirectories. - An enumerable collection of file system entries in the directory specified by and that match the specified and . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names in a specified . - An enumerable collection of file system entries in the directory specified by . - - - - - - - The transaction. - The directory to search. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file names and directory names that match a in a specified . - An enumerable collection of file system entries in the directory specified by and that match the specified . - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The path to test. - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The path to test. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The transaction. - The path to test. - - - [AlphaFS] Determines whether the given path refers to an existing directory on disk. - - Returns if refers to an existing directory. - Returns if the directory does not exist or an error occurs when trying to determine if the specified file exists. - - - The Exists method returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - The transaction. - The path to test. - Indicates the format of the path parameter(s). - - - Returns the names of subdirectories (including their paths) in the specified directory. - An array of the full names (including paths) of subdirectories in the specified path, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - - Returns the names of subdirectories (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) of the subdirectories that match the search pattern in the specified directory, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of the subdirectories (including their paths) that match the specified search pattern in the specified directory, and optionally searches subdirectories. - An array of the full names (including paths) of the subdirectories that match the specified criteria, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of subdirectories (including their paths) in the specified directory. - An array of the full names (including paths) of subdirectories in the specified path, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - - Returns the names of subdirectories (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) of the subdirectories that match the search pattern in the specified directory, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of the subdirectories (including their paths) that match the specified search pattern in the specified directory, and optionally searches subdirectories. - An array of the full names (including paths) of the subdirectories that match the specified criteria, or an empty array if no directories are found. - - The names returned by this method are prefixed with the directory information provided in path. - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of files (including their paths) in the specified directory. - An array of the full names (including paths) for the files in the specified directory, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - - Returns the names of files (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of files (including their paths) that match the specified search pattern in the current directory, and optionally searches subdirectories. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern and option, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of files (including their paths) in the specified directory. - An array of the full names (including paths) for the files in the specified directory, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - - Returns the names of files (including their paths) that match the specified search pattern in the specified directory. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns the names of files (including their paths) that match the specified search pattern in the current directory, and optionally searches subdirectories. - An array of the full names (including paths) for the files in the specified directory that match the specified search pattern and option, or an empty array if no files are found. - - The returned file names are appended to the supplied parameter. - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - - - Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the creation date and time of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the creation date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The directory for which to obtain access date and time information. - - - Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The transaction. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in local time. - The transaction. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The transaction. - The directory for which to obtain access date and time information. - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - A structure set to the date and time that the specified directory was last accessed. This value is expressed in UTC time. - The transaction. - The directory for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - - Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The directory for which to obtain write date and time information. - - - Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The transaction. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in local time. - The transaction. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The transaction. - The directory for which to obtain write date and time information. - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to. - A structure set to the date and time that the specified directory was last written to. This value is expressed in UTC time. - The transaction. - The directory for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Check if the directory has permission inheritance enabled. - if permission inheritance is enabled, if permission inheritance is disabled. - The full path to the directory to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Check if the directory has permission inheritance enabled. - The full path to the directory to check. - if permission inheritance is enabled, if permission inheritance is disabled. - - - Gets a object that encapsulates the access control list (ACL) entries for the specified directory. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a directory containing a object that describes the file's access control list (ACL) information. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - The path to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for the specified directory. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a directory containing a object that describes the file's access control list (ACL) information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - The path to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for the specified directory handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a directory containing a object that describes the directory's access control list (ACL) information. - - - [AlphaFS] Gets a object that encapsulates the specified type of access control list (ACL) entries for a particular directory handle. - A object that encapsulates the access control rules for the directory described by the parameter. - - - - A to a directory containing a object that describes the directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in local time. - The transaction. - The directory for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory. - A structure set to the change date and time for the specified directory. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - - Gets the current working directory of the application. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path of the current working directory without a trailing directory separator. - - - - Sets the application's current working directory to the specified directory. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path to which the current working directory is set. - - - - Sets the application's current working directory to the specified directory. - - MSDN: Multithreaded applications and shared library code should not use the GetCurrentDirectory function and should avoid using relative path names. - The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetFullPathName functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - The path to which the current working directory is set. - Indicates the format of the path parameter. - - - Returns the names of all files and subdirectories in the specified directory. - An string[] array of the names of files and subdirectories in the specified directory. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory for which file and subdirectory names are returned. - - - Returns an array of file system entries that match the specified search criteria. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The path to be searched. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Gets an array of all the file names and directory names that match a in a specified path, and optionally searches subdirectories. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the names of all files and subdirectories in the specified directory. - An string[] array of the names of files and subdirectories in the specified directory. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory for which file and subdirectory names are returned. - - - Returns an array of file system entries that match the specified search criteria. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The path to be searched. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Gets an array of all the file names and directory names that match a in a specified path, and optionally searches subdirectories. - An string[] array of file system entries that match the specified search criteria. - - The EnumerateFileSystemEntries and GetFileSystemEntries methods differ as follows: When you use EnumerateFileSystemEntries, - you can start enumerating the collection of entries before the whole collection is returned; when you use GetFileSystemEntries, - you must wait for the whole array of entries to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - The transaction. - The directory to search. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The path of a file or directory. - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The path of a file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - Indicates the format of the path parameter(s). - - - Returns the volume information, root information, or both for the specified path. - The volume information, root information, or both for the specified path, or if path does not contain root directory information. - - - - The transaction. - The path of a file or directory. - Indicates the format of the path parameter(s). - - - Retrieves the names of the logical drives on this computer in the form "<drive letter>:\". - An array of type that represents the logical drives on a computer. - - - [AlphaFS] Retrieves the names of the logical drives on this computer in the form "<drive letter>:\". - An array of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - [AlphaFS] Enumerates the drive names of all logical drives on a computer. - An IEnumerable of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - Enumerates the drive names of all logical drives on a computer. - An IEnumerable of type that represents the logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The path for which to retrieve the parent directory. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - - - [AlphaFS] Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - Retrieves the parent directory of the specified path, including both absolute and relative paths. - The parent directory, or if is the root directory, including the root of a UNC server or share name. - The transaction. - The path for which to retrieve the parent directory. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a object to the specified directory. - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - Note that unlike this method does not automatically - determine what parts of the specified instance has been modified. Instead, the - parameter is used to specify what entries from to apply to . - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - Note that unlike this method does not automatically - determine what parts of the specified instance has been modified. Instead, the - parameter is used to specify what entries from to apply to . - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a object to the specified directory. - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - Indicates the format of the path parameter(s). - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time the directory was created. - The directory for which to set the creation date and time information. - Indicates the format of the path parameter(s). - A containing the value to set for the creation date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the directory was created. - The transaction. - The directory for which to set the creation date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The file for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed. - The transaction. - The directory for which to set the access date and time information. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in local time. - A containing the value to set for the last access date and time of . This value is expressed in local time. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified directory, at once. - The transaction. - The directory for which to set the dates and times information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The transaction. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified directories. - This method uses BackupSemantics flag to get Timestamp changed for directories. - The transaction. - The source directory to get the date and time stamps from. - The destination directory to set the date and time stamps. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in local time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified directory was last written to. - The transaction. - The directory for which to set the date and time information. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - A path that describes a directory to compress. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - A path that describes a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to compress. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - The transaction. - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - The transaction. - A path that describes a directory to compress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - A path that describes a directory to decompress. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - A path that describes a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to decompress. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - The transaction. - A path that describes a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - The transaction. - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - The transaction. - A path that describes a directory to decompress. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - A path to a directory to decompress. - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - A path to a directory to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - The transaction. - A path to a directory to decompress. - - - [AlphaFS] Disables NTFS compression of the specified directory and the files in it. - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. However, newly created files and directories will be uncompressed. - - - - - - - The transaction. - Indicates the format of the path parameter(s). - A path to a directory to decompress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - A path to a directory to compress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - A path to a directory to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - The transaction. - A path to a directory to compress. - - - [AlphaFS] Enables NTFS compression of the specified directory and the files in it. - This method enables the directory-compression attribute. It will not compress the current contents of the directory. However, newly created files and directories will be compressed. - - - - - - - The transaction. - A path to a directory to compress. - Indicates the format of the path parameter(s). - - - Compress/decompress Non-/Transacted files/directories. - - - - - - - The transaction. - A path that describes a directory to compress. - - The search string to match against the names of directories in . - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - compress, when decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - to decrypt the directory recursively. only decrypt the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - A path that describes a directory to decrypt. - to decrypt the directory recursively. only decrypt the directory. - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - Indicates the format of the path parameter(s). - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - to encrypt the directory recursively. only encrypt the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - to encrypt the directory recursively. only encrypt the directory. - - - [AlphaFS] Disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and disables encryption by writing: "Disable=1" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to disable encryption. - Indicates the format of the path parameter(s). - - - [AlphaFS] Disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and disables encryption by writing: "Disable=1" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to disable encryption. - - - [AlphaFS] Enables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables encryption by writing: "Disable=0" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables encryption by writing: "Disable=0" - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - - - Enables/disables encryption of the specified directory and the files in it. - This method only creates/modifies the file "Desktop.ini" in the root of and enables/disables encryption by writing: "Disable=0" or "Disable=1". - This method does not affect encryption of files and subdirectories below the indicated directory. - - The name of the directory for which to enable encryption. - enabled encryption, disables encryption. - Indicates the format of the path parameter(s). - - - Decrypts/encrypts a directory recursively so that only the account used to encrypt the directory can decrypt it. - - - - - - - A path that describes a directory to encrypt. - encrypt, decrypt. - to decrypt the directory recursively. only decrypt files and directories in the root of . - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory handle specified. - An IEnumerable of records for each file system entry in the specified diretory. - An open handle to the directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - - - [AlphaFS] Retrieves information about files in the directory specified by in mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - - - [AlphaFS] Retrieves information about files in the directory specified by in specified mode. - An enumeration of records for each file system entry in the specified diretory. - The transaction. - A path to a directory from which to retrieve information. - The mode with which to open a handle to the directory. - Indicates the format of the path parameter(s). - - - Returns an enumerable collection of information about files in the directory handle specified. - An IEnumerable of records for each file system entry in the specified diretory. - - Either use or , not both. - - The number of files that are returned for each call to GetFileInformationByHandleEx depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle will resume the enumeration operation after the last file is returned. - - - The transaction. - An open handle to the directory from which to retrieve information. - A path to the directory. - The mode with which to open a handle to the directory. - suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the properties of the particular directory without following any symbolic links or mount points. - Properties include aggregated info from of each encountered file system object, plus additional ones: Total, File, Size and Error. - Total: is the total number of enumerated objects. - File: is the total number of files. File is considered when object is neither nor . - Size: is the total size of enumerated objects. - Error: is the total number of errors encountered during enumeration. - - A dictionary mapping the keys mentioned above to their respective aggregated values. - Directory: is an object which has attribute without one. - - - - - - - The transaction. - The target directory. - flags that specify how the directory is to be enumerated. - Indicates the format of the path parameter(s). - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The path to the directory to enumerate streams of. - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The path to the directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The transaction. - The path to the directory to enumerate streams of. - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified directory. - The transaction. - The path to the directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified directory. - - - [AlphaFS] Backs up (export) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The directory being backed up is not decrypted; it is backed up in its encrypted state. - If the caller does not have access to the key for the file, the caller needs to export encrypted files. See . - To backup an encrypted directory call one of the overloads and specify the directory to backup along with the destination stream of the backup data. - This function is intended for the backup of only encrypted directories; see for backup of unencrypted directories. - Note that this method does not back up the files inside the directory, only the directory entry itself. - - - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - - - [AlphaFS] Backs up (export) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The directory being backed up is not decrypted; it is backed up in its encrypted state. - If the caller does not have access to the key for the file, the caller needs to export encrypted files. See . - To backup an encrypted directory call one of the overloads and specify the directory to backup along with the destination stream of the backup data. - This function is intended for the backup of only encrypted directories; see for backup of unencrypted directories. - Note that this method does not back up the files inside the directory, only the directory entry itself. - - - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - The path format of the parameter. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - The path format of the parameter. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - If set to a hidden directory will be overwritten on import. - - - [AlphaFS] Restores (import) encrypted directories. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the directory, the caller needs to restore encrypted directories. See . - To restore an encrypted directory call one of the overloads and specify the file to restore along with the destination stream of the restored data. - This function is intended for the restoration of only encrypted directories; see for backup of unencrypted files. - - - - - The stream to read previously backed up data from. - The path of the destination directory to restore to. - If set to a hidden directory will be overwritten on import. - The path format of the parameter. - - - Exposes instance methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited. - - - Refreshes the state of the EntryInfo instance. - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - to decrypt the directory recursively. only decrypt files and directories in the root of the directory. - - - [AlphaFS] Disables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories below the indicated directory. - on success, otherwise. - This method will create/change the file "Desktop.ini" and wil set Encryption value: "Disable=0" - - - [AlphaFS] Enables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories below the indicated directory. - on success, otherwise. - This method will create/change the file "Desktop.ini" and wil set Encryption value: "Disable=1" - - - [AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it. - - - - - - - - - [AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method. - - - - - - - to encrypt the directory recursively. only encrypt files and directories in the root of the directory. - - - [AlphaFS] Deletes empty subdirectories from the instance. - - - [AlphaFS] Deletes empty subdirectories from the instance. - deletes empty subdirectories from this directory and its subdirectories. - - - [AlphaFS] Deletes empty subdirectories from the instance. - deletes empty subdirectories from this directory and its subdirectories. - overrides read only of empty directories. - - - [AlphaFS] Compresses a directory using NTFS compression. - This will only compress the root items (non recursive). - - - - - - - - - [AlphaFS] Compresses a directory using NTFS compression. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Decompresses an NTFS compressed directory. - This will only decompress the root items (non recursive). - - - - - - - - - [AlphaFS] Decompresses an NTFS compressed directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Disables compression of the specified directory and the files in it. - - This method disables the directory-compression attribute. It will not decompress the current contents of the directory. - However, newly created files and directories will be uncompressed. - - - - [AlphaFS] Enables compression of the specified directory and the files in it. - - This method enables the directory-compression attribute. It will not compress the current contents of the directory. - However, newly created files and directories will be compressed. - - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Counts file system objects: files, folders or both) in a given directory. - The counted number of file system objects. - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Copies a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely copied. - - - - - - - The destination directory path. - - - [AlphaFS] Copies a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely copied. - - - - - - - The destination directory path. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - Returns a new directory, or an overwrite of an existing directory if is not . - If the directory exists and contains , an is thrown. - - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - Returns a new directory, or an overwrite of an existing directory if is not . - If the directory exists and contains , an is thrown. - - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing directory to a new directory, allowing the overwriting of an existing directory, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing directory. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - The destination directory path. - that specify how the directory is to be copied. This parameter can be . - A callback function that is called each time another portion of the directory has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - - - Moves a instance and its contents to a new path. - - Use this method to prevent overwriting of an existing directory by default. - This method does not work across disk volumes. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance if the directory was completely moved. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a instance and its contents to a new path, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing directory. - This method does not work across disk volumes unless contains . - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The name and path to which to move this directory. - The destination cannot be another disk volume unless contains , or a directory with the identical name. - It can be an existing directory to which you want to add this directory as a subdirectory. - - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move a Non-/Transacted file or directory including its children to a new location, - or can be specified, and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless contains . - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an IOException. - - - A class with details of the Copy or Move action. - - - - - - - The destination directory path. - that specify how the file is to be copied. This parameter can be . - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Returns the retrieved long full path. - Indicates the format of the path parameter(s). - - - Returns the original path that was passed by the user. - A string that represents this object. - - - Applies access control list (ACL) entries described by a object to the directory described by the current DirectoryInfo object. - A object that describes an ACL entry to apply to the directory described by the path parameter. - - - Applies access control list (ACL) entries described by a object to the directory described by the current DirectoryInfo object. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Refreshes the state of the object. - - - Returns an array of strongly typed entries representing all the files and subdirectories in a directory. - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Retrieves an array of strongly typed objects representing the files and subdirectories that match the specified search criteria. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Retrieves an array of strongly typed objects representing the files and subdirectories that match the specified search criteria. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - An array of strongly typed entries. - - For subdirectories, the objects returned by this method can be cast to the derived class . - Use the value returned by the property to determine whether the represents a file or a directory. - - - If there are no files or directories in the DirectoryInfo, this method returns an empty array. This method is not recursive. - For subdirectories, the FileSystemInfo objects returned by this method can be cast to the derived class DirectoryInfo. - Use the FileAttributes value returned by the Attributes property to determine whether the FileSystemInfo represents a file or a directory. - - - - - - - - - - Returns a file list from the current directory. - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns a file list from the current directory matching the given search pattern. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns a file list from the current directory matching the given search pattern and using a value to determine whether to search subdirectories. - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - An array of type . - The order of the returned file names is not guaranteed; use the Sort() method if a specific sort order is required. - If there are no files in the , this method returns an empty array. - - The EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names - before the whole collection is returned; when you use GetFiles, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateFiles can be more efficient. - - - - - - - - - - Returns the subdirectories of the current directory. - An array of objects. - If there are no subdirectories, this method returns an empty array. This method is not recursive. - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - - Returns an array of directories in the current matching the given search criteria. - An array of type matching . - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an array of directories in the current matching the given search criteria and using a value to determine whether to search subdirectories. - An array of type matching . - If there are no subdirectories, or no subdirectories match the searchPattern parameter, this method returns an empty array. - - The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names - before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. - Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient. - - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Gets a object that encapsulates the access control list (ACL) entries for the directory described by the current DirectoryInfo object. - A object that encapsulates the access control rules for the directory. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for the directory described by the current object. - One of the values that specifies the type of access control list (ACL) information to receive. - A object that encapsulates the access control rules for the file described by the path parameter. - - - Returns an enumerable collection of file system information in the current directory. - An enumerable collection of file system information in the current directory. - - - - - - - - - Returns an enumerable collection of file system information that matches a specified search pattern. - An enumerable collection of file system information objects that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file system information that matches a specified search pattern and search subdirectory option. - An enumerable collection of file system information objects that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of file system information in the current directory. - An enumerable collection of file system information in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - [AlphaFS] Returns an enumerable collection of file system information that matches a specified search pattern. - An enumerable collection of file system information objects that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of file information in the current directory. - An enumerable collection of the files in the current directory. - - - - - - - - - Returns an enumerable collection of file information that matches a search pattern. - An enumerable collection of files that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of file information that matches a specified search pattern and search subdirectory option. - An enumerable collection of files that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - Returns an enumerable collection of file information in the current directory. - An enumerable collection of the files in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of file information that matches a search pattern. - An enumerable collection of files that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of directory information in the current directory. - An enumerable collection of directories in the current directory. - - - - - - - - - Returns an enumerable collection of directory information that matches a specified search pattern. - An enumerable collection of directories that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - - Returns an enumerable collection of directory information that matches a specified search pattern and search subdirectory option. - An enumerable collection of directories that matches and . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - - One of the enumeration values that specifies whether the - should include only the current directory or should include all subdirectories. - - - - [AlphaFS] Returns an enumerable collection of directory information in the current directory. - An enumerable collection of directories in the current directory. - - - - - - - flags that specify how the directory is to be enumerated. - - - Returns an enumerable collection of directory information that matches a specified search pattern. - An enumerable collection of directories that matches . - - - - - - - - The search string to match against the names of directories in path. - This parameter can contain a combination of valid literal path and wildcard - ( and ) characters, but does not support regular expressions. - - flags that specify how the directory is to be enumerated. - - - Deletes this if it is empty. - - - - - - - - - Deletes this instance of a , specifying whether to delete subdirectories and files. - - If the has no files or subdirectories, this method deletes the even if recursive is . - Attempting to delete a that is not empty when recursive is false throws an . - - - - - - - - to delete this directory, its subdirectories, and all files; otherwise, . - - - [AlphaFS] Deletes this instance of a , specifying whether to delete files and subdirectories. - - If the has no files or subdirectories, this method deletes the even if recursive is . - Attempting to delete a that is not empty when recursive is false throws an . - - - - - - - - to delete this directory, its subdirectories, and all files; otherwise, . - ignores read only attribute of files and directories. - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The security to apply. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - The specified path. This cannot be a different disk volume. - When compresses the directory. - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The path of the directory to use as a template when creating the new directory. - When compresses the directory. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The specified path. This cannot be a different disk volume. - The security to apply. - When compresses the directory. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - [AlphaFS] Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the class. - The path of the directory to use as a template when creating the new directory. - The specified path. This cannot be a different disk volume. - When compresses the directory. - The security to apply. - The last directory specified in . - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - - - Creates a subdirectory or subdirectories on the specified path. The specified path can be relative to this instance of the DirectoryInfo class. - The last directory specified in path as an object. - - Any and all directories specified in path are created, unless some part of path is invalid. - The path parameter specifies a directory path, not a file path. - If the subdirectory already exists, this method does nothing. - - The specified path. This cannot be a different disk volume or Universal Naming Convention (UNC) name. - The path of the directory to use as a template when creating the new directory. - The security to apply. - When compresses the directory. - - - Creates a directory. - If the directory already exists, this method does nothing. - - - Creates a directory using a object. - The access control to apply to the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Creates a directory using a object. - When compresses the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Creates a directory using a object. - The access control to apply to the directory. - When compresses the directory. - If the directory already exists, this method does nothing. - - - [AlphaFS] Returns an enumerable collection of instances for the directory. - An enumerable collection of instances for the directory. - - - Initializes a new instance of the class on the specified path. - The path on which to create the . - - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - The path parameter can be a file name, including a file on a Universal Naming Convention (UNC) share. - - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The path on which to create the . - Indicates the format of the path parameter(s). - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Special internal implementation. - The transaction. - The full path on which to create the . - Not used. - Not used. - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The transaction. - The path on which to create the . - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class on the specified path. - The transaction. - The path on which to create the . - Indicates the format of the path parameter(s). - This constructor does not check if a directory exists. This constructor is a placeholder for a string that is used to access the disk in subsequent operations. - - - Gets a value indicating whether the directory exists. - - The property returns if any error occurs while trying to determine if the - specified directory exists. - This can occur in situations that raise exceptions such as passing a directory name with invalid characters or too many - characters, - a failing or missing disk, or if the caller does not have permission to read the directory. - - if the directory exists; otherwise, . - - - Gets the name of this instance. - The directory name. - - This Name property returns only the name of the directory, such as "Bin". - To get the full path, such as "c:\public\Bin", use the FullName property. - - - - Gets the parent directory of a specified subdirectory. - The parent directory, or null if the path is null or if the file path denotes a root (such as "\", "C:", or * "\\server\share"). - - - Gets the root portion of the directory. - An object that represents the root of the directory. - - - Indicates the operation to be performed when opening a file using the OpenEncryptedFileRaw. - - - (0) Open the file for export (backup). - - - (1) The file is being opened for import (restore). - - - (2) Import (restore) a directory containing encrypted files. This must be combined with one of the previous two flags to indicate the operation. - - - (4) Overwrite a hidden file on import. - - - Defines values that are used with the FindFirstStreamW function to specify the information level of the returned data. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - The FindFirstStreamW function retrieves standard stream information. The data is returned in a structure. - - - Used to determine valid enumeration values. All supported enumeration values are less than FindStreamInfoMaxInfoLevel. - - - Specifies control options that filter the device information elements that are added to the device information set. - - - DIGCF_DEFAULT - Return only the device that is associated with the system default device interface, if one is set, for the specified device interface classes. - - - - DIGCF_PRESENT - Return only devices that are currently present. - - - - DIGCF_ALLCLASSES - Return a list of installed devices for the specified device setup classes or device interface classes. - - - - DIGCF_PROFILE - Return only devices that are a part of the current hardware profile. - - - - DIGCF_DEVICEINTERFACE - - Return devices that support device interfaces for the specified device interface classes. - This flag must be set in the Flags parameter if the Enumerator parameter specifies a Device Instance ID. - - - - - FILE_INFO_BY_HANDLE_CLASS - Identifies the type of file information that GetFileInformationByHandleEx should retrieve or SetFileInformationByHandle should set. - - - - FILE_BASIC_INFO - Minimal information for the file should be retrieved or set. Used for file handles. - - - - FILE_ID_BOTH_DIR_INFO - Files in the specified directory should be retrieved. Used for directory handles. - Use only when calling GetFileInformationByHandleEx. - - The number of files returned for each call to GetFileInformationByHandleEx - depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle - will resume the enumeration operation after the last file is returned. - - - - - Additional flags that control the search. - - - No additional flags used. - - - Searches are case-sensitive. - - - Uses a larger buffer for directory queries, which can increase performance of the find operation. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FINDEX_INFO_LEVELS Enumeration - Defines values that are used with the FindFirstFileEx function to specify the information level of the returned data. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - - A standard set of attribute is returned in a structure. - - - The FindFirstFileEx function does not query the short file name, improving overall enumeration speed. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FINDEX_SEARCH_OPS Enumeration - Defines values that are used with the FindFirstFileEx function to specify the type of filtering to perform. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - - The search for a file that matches a specified file name. - The lpSearchFilter parameter of FindFirstFileEx must be NULL when this search operation is used. - - - - This is an advisory flag. If the file system supports directory filtering, - the function searches for a file that matches the specified name and is also a directory. - If the file system does not support directory filtering, this flag is silently ignored. -   - - The lpSearchFilter parameter of the FindFirstFileEx function must be NULL when this search value is used. - If directory filtering is desired, this flag can be used on all file systems, - but because it is an advisory flag and only affects file systems that support it, - the application must examine the file attribute data stored in the lpFindFileData parameter - of the FindFirstFileEx function to determine whether the function has returned a handle to a directory. - - - - - This filtering type is not available. - For more information, see Device Interface Classes. - - - Enum for struct ChangeErrorMode. - - - Use the system default, which is to display all error dialog boxes. - - - The system does not display the critical-error-handler message box. Instead, the system sends the error to the calling process/thread. - - - The system does not display the Windows Error Reporting dialog. - - - The system automatically fixes memory alignment faults and makes them invisible to the application. It does this for the calling process and any descendant processes. This feature is only supported by certain processor architectures. - - - The system does not display a message box when it fails to find a file. Instead, the error is returned to the calling process/thread. - - - Flags for SetupDiGetDeviceRegistryProperty(). - - - SPDRP_DEVICEDESC - Represents a description of a device instance. - - - - SPDRP_HARDWAREID - Represents the list of hardware identifiers for a device instance. - - - - SPDRP_COMPATIBLEIDS - Represents the list of compatible identifiers for a device instance. - - - - SPDRP_CLASS - Represents the name of the service that is installed for a device instance. - - - - SPDRP_CLASS - Represents the name of the device setup class that a device instance belongs to. - - - - SPDRP_CLASSGUID - Represents the of the device setup class that a device instance belongs to. - - - - SPDRP_DRIVER - Represents the registry entry name of the driver key for a device instance. - - - - SPDRP_MFG - Represents the name of the manufacturer of a device instance. - - - - SPDRP_FRIENDLYNAME - Represents the friendly name of a device instance. - - - - SPDRP_LOCATION_INFORMATION - Represents the bus-specific physical location of a device instance. - - - - SPDRP_PHYSICAL_DEVICE_LOCATION - Encapsulates the physical device location information provided by a device's firmware to Windows. - - - - SPDRP_ENUMERATOR_NAME - Represents the name of the enumerator for a device instance. - - - - SPDRP_LOCATION_PATHS - Represents the location of a device instance in the device tree. - - - - SPDRP_BASE_CONTAINERID - Represents the value of the base container identifier (ID) .The Windows Plug and Play (PnP) manager assigns this value to the device node (devnode). - - - - Volume Attributes used by the GetVolumeInfo() function. - - - No VolumeInfo attributes. - - - FILE_CASE_SENSITIVE_SEARCH - The specified volume supports case-sensitive file names. - - - - FILE_CASE_PRESERVED_NAMES - The specified volume supports preserved case of file names when it places a name on disk. - - - - FILE_UNICODE_ON_DISK - The specified volume supports Unicode in file names as they appear on disk. - - - - FILE_PERSISTENT_ACLS - - The specified volume preserves and enforces access control lists (ACL). - For example, the NTFS file system preserves and enforces ACLs, and the FAT file system does not. - - - - - FILE_FILE_COMPRESSION - The specified volume supports file-based compression. - - - - FILE_VOLUME_QUOTAS - The specified volume supports disk quotas. - - - - FILE_SUPPORTS_SPARSE_FILES - The specified volume supports sparse files. - - - - FILE_SUPPORTS_REPARSE_POINTS - The specified volume supports re-parse points. - - - - (does not appear on MSDN) - - - FILE_VOLUME_IS_COMPRESSED - The specified volume is a compressed volume, for example, a DoubleSpace volume. - - - - FILE_SUPPORTS_OBJECT_IDS - The specified volume supports object identifiers. - - - - FILE_SUPPORTS_ENCRYPTION - The specified volume supports the Encrypted File System (EFS). For more information, see File Encryption. - - - - FILE_NAMED_STREAMS - The specified volume supports named streams. - - - - FILE_READ_ONLY_VOLUME - The specified volume is read-only. - - - - FILE_SEQUENTIAL_WRITE_ONCE - The specified volume is read-only. - - - - FILE_SUPPORTS_TRANSACTIONS - The specified volume supports transactions.For more information, see About KTM. - - - - FILE_SUPPORTS_HARD_LINKS - The specified volume supports hard links. For more information, see Hard Links and Junctions. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_EXTENDED_ATTRIBUTES - - The specified volume supports extended attributes. An extended attribute is a piece of application-specific metadata - that an application can associate with a file and is not part of the file's data. - - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_OPEN_BY_FILE_ID - The file system supports open by FileID. For more information, see FILE_ID_BOTH_DIR_INFO. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - FILE_SUPPORTS_USN_JOURNAL - The specified volume supports update sequence number (USN) journals. For more information, see Change Journal Records. - - Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This value is not supported until Windows Server 2008 R2 and Windows 7. - - - Defines values that are used with the GetFileAttributesEx and GetFileAttributesTransacted functions to specify the information level of the returned data. - - - The GetFileAttributesEx or GetFileAttributesTransacted function retrieves a standard set of attribute information. The data is returned in a WIN32_FILE_ATTRIBUTE_DATA structure. - - - Opens an encrypted file in order to backup (export) or restore (import) the file. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - The name of the file to be opened. - The operation to be performed. - [out] The address of a context block that must be presented in subsequent calls to - ReadEncryptedFileRaw, WriteEncryptedFileRaw, or CloseEncryptedFileRaw. - - - Closes an encrypted file after a backup or restore operation, and frees associated system resources. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - A pointer to a system-defined context block. The OpenEncryptedFileRaw function returns the context block. - - - Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is intended to implement backup and restore functionality, while maintaining files in their encrypted state. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is intended to implement backup and restore functionality, while maintaining files in their encrypted state. - If the function succeeds, it returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. You can use FormatMessage with the FORMAT_MESSAGE_FROM_SYSTEM flag to get a generic text description of the error. - Minimum supported client: Windows XP Professional [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Returns a pointer to an IQueryAssociations object. - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Searches for and retrieves a file or protocol association-related string from the registry. - Return value Type: HRESULT. Returns a standard COM error value, including the following: S_OK, E_POINTER and S_FALSE. - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - Exposes methods that simplify the process of retrieving information stored in the registry in association with defining a file type or protocol and associating it with an application. - - - Initializes the IQueryAssociations interface and sets the root key to the appropriate ProgID. - If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Searches for and retrieves a file or protocol association-related string from the registry. - A standard COM error value, including the following: S_OK, E_POINTER, S_FALSE - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Determines whether a path to a file system object such as a file or folder is valid. - if the file exists; otherwise, . Call GetLastError for extended error information. - - This function tests the validity of the path. - A path specified by Universal Naming Convention (UNC) is limited to a file only; that is, \\server\share\file is permitted. - A network share path to a server or server share is not permitted; that is, \\server or \\server\share. - This function returns FALSE if a mounted remote drive is out of service. - - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - Converts a file URL to a Microsoft MS-DOS path. - Type: HRESULT - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Creates a path from a file URL. - Type: HRESULT - If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Converts a Microsoft MS-DOS path to a canonicalized URL. - Type: HRESULT - Returns S_FALSE if pszPath is already in URL format. In this case, pszPath will simply be copied to pszUrl. - Otherwise, it returns S_OK if successful or a standard COM error value if not. - - - UrlCreateFromPath does not support extended paths. These are paths that include the extended-length path prefix "\\?\". - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Tests whether a URL is a specified type. - - Type: BOOL - For all but one of the URL types, UrlIs returns if the URL is the specified type, otherwise. - If UrlIs is set to , UrlIs will attempt to determine the URL scheme. - If the function is able to determine a scheme, it returns , or . - - Minimum supported client: Windows 2000 Professional, Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Destroys an icon and frees any memory the icon occupied. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - Retrieves information about an object in the file system, such as a file, folder, directory, or drive root. - You should call this function from a background thread. Failure to do so could cause the UI to stop responding. - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Creates a new transaction object. - - - Use the function to close the transaction handle. If the last transaction handle is closed - beforea client calls the CommitTransaction function with the transaction handle, then KTM rolls back the transaction. - Minimum supported client: Windows Vista - Minimum supported server:Windows Server 2008 - - - If the function succeeds, the return value is a handle to the transaction. - If the function fails, the return value is INVALID_HANDLE_VALUE. To get extended error information, call the GetLastError - function. - - - - Requests that the specified transaction be committed. - - You can commit any transaction handle that has been opened or created using the TRANSACTION_COMMIT permission; any - application can commit a transaction, not just the creator. - This function can only be called if the transaction is still active, not prepared, pre-prepared, or rolled back. - Minimum supported client: Windows Vista - Minimum supported server:Windows Server 2008 - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is 0 (zero). To get extended error information, call the GetLastError function. - - - - - Requests that the specified transaction be rolled back. This function is synchronous. - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call the GetLastError function. - - - - Closes an open object handle. - - The CloseHandle function closes handles to the following objects: - Access token, Communications device, Console input, Console screen buffer, Event, File, File mapping, I/O completion port, - Job, Mailslot, Memory resource notification, Mutex, Named pipe, Pipe, Process, Semaphore, Thread, Transaction, Waitable - timer. - SetLastError is set to . - Minimum supported client: Windows 2000 Professional [desktop apps | Windows Store apps] - Minimum supported server: Windows 2000 Server [desktop apps | Windows Store apps] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - If the application is running under a debugger, the function will throw an exception if it receives either a handle value - that is not valid or a pseudo-handle value.This can happen if you close a handle twice, or if you call CloseHandle on a handle - returned by the FindFirstFile function instead of calling the FindClose function. - - - - - Copies an existing file to a new file, notifying the application of its progress through a callback function. - - - This function fails with ERROR_ACCESS_DENIED if the destination file already exists and has the FILE_ATTRIBUTE_HIDDEN or - FILE_ATTRIBUTE_READONLY attribute set. - This function preserves extended attributes, OLE structured storage, NTFS file system alternate data streams, security - resource attributes, and file attributes. - Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: - Security resource attributes (ATTRIBUTE_SECURITY_INFORMATION) for the existing file are not copied to the new file until - Windows 8 and Windows Server 2012. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Filename of the existing file. - Filename of the new file. - The progress routine. - The data. - [out] The pb cancel. - The copy flags. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Copies an existing file to a new file as a transacted operation, notifying the application of its progress through a callback - function. - - - This function fails with ERROR_ACCESS_DENIED if the destination file already exists and has the FILE_ATTRIBUTE_HIDDEN or - FILE_ATTRIBUTE_READONLY attribute set. - This function preserves extended attributes, OLE structured storage, NTFS file system alternate data streams, security - resource attributes, and file attributes. - Windows 7, Windows Server 2008 R2, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: - Security resource attributes (ATTRIBUTE_SECURITY_INFORMATION) for the existing file are not copied to the new file until - Windows 8 and Windows Server 2012. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical - disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is an open handle to the specified file, device, named pipe, or mail slot. If the - function fails, the return value is Win32Errors.ERROR_INVALID_HANDLE. To get extended error information, call GetLastError. - - - - - Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical - disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is an open handle to the specified file, device, named pipe, or mail slot. If the - function fails, the return value is Win32Errors.ERROR_INVALID_HANDLE". To get extended error information, call GetLastError. - - - - Creates or opens a named or unnamed file mapping object for a specified file. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is a handle to the newly created file mapping object. If the function fails, the return - value is . - - - - - Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only - for files, not directories. - - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - - Establishes a hard link between an existing file and a new file as a transacted operation. This function is only supported on the - NTFS file system, and only for files, not directories. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Creates a symbolic link. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - The unmanaged prototype contains a return directive because the CreateSymbolicLink API function returns BOOLEAN, a one-byte data type. - The default marshaling for bool is four bytes (to allow seamless integration with BOOL return values). - If you were to use the default marshaling for BOOLEAN values, it's likely that you will get erroneous results. - The return directive forces PInvoke to marshal just one byte of the return value. - Source: http://www.informit.com/guides/content.aspx?g=dotnet&seqNum=762&ns=16196 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Creates a symbolic link as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - The unmanaged prototype contains a return directive because the CreateSymbolicLink API function returns BOOLEAN, a one-byte data type. - The default marshaling for bool is four bytes (to allow seamless integration with BOOL return values). - If you were to use the default marshaling for BOOLEAN values, it's likely that you will get erroneous results. - The return directive forces PInvoke to marshal just one byte of the return value. - Source: http://www.informit.com/guides/content.aspx?g=dotnet&seqNum=762&ns=16196 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Decrypts an encrypted file or directory. - - The DecryptFile function requires exclusive access to the file being decrypted, and will fail if another process is using the file. - If the file is not encrypted, DecryptFile simply returns a nonzero value, which indicates success. If lpFileName specifies a read- - only file, the function fails and GetLastError returns ERROR_FILE_READ_ONLY. If lpFileName specifies a directory that contains a - read-only file, the functions succeeds but the directory is not decrypted. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Deletes an existing file. - - If an application attempts to delete a file that does not exist, the DeleteFile function fails with ERROR_FILE_NOT_FOUND. - - If the file is a read-only file, the function fails with ERROR_ACCESS_DENIED. - - If the path points to a symbolic link, the symbolic link is deleted, not the target. To delete a target, you must call CreateFile - and specify FILE_FLAG_DELETE_ON_CLOSE. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - Deletes an existing file as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. - - - - - Encrypts a file or directory. All data streams in a file are encrypted. All new files created in an encrypted directory are - encrypted. - - - The EncryptFile function requires exclusive access to the file being encrypted, and will fail if another process is using the file. - If the file is already encrypted, EncryptFile simply returns a nonzero value, which indicates success. If the file is compressed, - EncryptFile will decompress the file before encrypting it. If lpFileName specifies a read-only file, the function fails and - GetLastError returns ERROR_FILE_READ_ONLY. If lpFileName specifies a directory that contains a read-only file, the functions - succeeds but the directory is not encrypted. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Disables or enables encryption of the specified directory and the files in it. It does not affect encryption of subdirectories - below the indicated directory. - - - EncryptionDisable() disables encryption of directories and files. It does not affect the visibility of files with the - FILE_ATTRIBUTE_SYSTEM attribute set. This method will create/change the file "Desktop.ini" and wil set Encryption value: - "Disable=0|1". - - Minimum supported client: Windows XP Professional [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves the encryption status of the specified file. - Minimum supported client: Windows XP Professional [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Closes a file search handle opened by the FindFirstFile, FindFirstFileEx, FindFirstFileNameW, FindFirstFileNameTransactedW, - FindFirstFileTransacted, FindFirstStreamTransactedW, or FindFirstStreamW functions. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Searches a directory for a file or subdirectory with a name and attributes that match those specified. - A trailing backslash is not allowed and will be removed. - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose, and the - lpFindFileData parameter contains information about the first file or directory found. If the function fails or fails to locate - files from the search string in the lpFileName parameter, the return value is INVALID_HANDLE_VALUE and the contents of - lpFindFileData are indeterminate. To get extended error information, call the GetLastError function. - - - - - Searches a directory for a file or subdirectory with a name that matches a specific name as a transacted operation. - - A trailing backslash is not allowed and will be removed. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose, and the - lpFindFileData parameter contains information about the first file or directory found. If the function fails or fails to locate - files from the search string in the lpFileName parameter, the return value is INVALID_HANDLE_VALUE and the contents of - lpFindFileData are indeterminate. To get extended error information, call the GetLastError function. - - - - - Creates an enumeration of all the hard links to the specified file. The FindFirstFileNameW function returns a handle to the - enumeration that can be used on subsequent calls to the FindNextFileNameW function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle that can be used with the FindNextFileNameW function or closed with - the FindClose function. If the function fails, the return value is INVALID_HANDLE_VALUE (0xffffffff). To get extended error - information, call the GetLastError function. - - - - - Creates an enumeration of all the hard links to the specified file as a transacted operation. The function returns a handle to the - enumeration that can be used on subsequent calls to the FindNextFileNameW function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is a search handle that can be used with the FindNextFileNameW function or closed with - the FindClose function. If the function fails, the return value is INVALID_HANDLE_VALUE (0xffffffff). To get extended error - information, call the GetLastError function. - - - - - Continues a file search from a previous call to the FindFirstFile, FindFirstFileEx, or FindFirstFileTransacted functions. - - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero and the lpFindFileData parameter contains information about the next file or - directory found. If the function fails, the return value is zero and the contents of lpFindFileData are indeterminate. To get - extended error information, call the GetLastError function. If the function fails because no more matching files can be found, the - GetLastError function returns ERROR_NO_MORE_FILES. - - - - - Continues enumerating the hard links to a file using the handle returned by a successful call to the FindFirstFileName function. - - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero (0). To get extended error - information, call GetLastError. If no matching files can be found, the GetLastError function returns ERROR_HANDLE_EOF. - - - - Flushes the buffers of a specified file and causes all buffered data to be written to a file. - Minimum supported client: Windows XP [desktop apps | Windows Store apps]. - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves the actual number of bytes of disk storage used to store a specified file. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is the low-order DWORD of the actual number of bytes of disk storage used to store the - specified file, and if lpFileSizeHigh is non-NULL, the function puts the high-order DWORD of that actual value into the DWORD - pointed to by that parameter. This is the compressed file size for compressed files, the actual file size for noncompressed files. - If the function fails, and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE. To get extended error information, call - GetLastError. If the return value is INVALID_FILE_SIZE and lpFileSizeHigh is non-NULL, an application must call GetLastError to - determine whether the function has succeeded (value is NO_ERROR) or failed (value is other than NO_ERROR). - - - - Retrieves the actual number of bytes of disk storage used to store a specified file as a transacted operation. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is the low-order DWORD of the actual number of bytes of disk storage used to store the - specified file, and if lpFileSizeHigh is non-NULL, the function puts the high-order DWORD of that actual value into the DWORD - pointed to by that parameter. This is the compressed file size for compressed files, the actual file size for noncompressed files. - If the function fails, and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE. To get extended error information, call - GetLastError. If the return value is INVALID_FILE_SIZE and lpFileSizeHigh is non-NULL, an application must call GetLastError to - determine whether the function has succeeded (value is NO_ERROR) or failed (value is other than NO_ERROR). - - - - - Retrieves attributes for a specified file or directory. - - - The GetFileAttributes function retrieves file system attribute information. - GetFileAttributesEx can obtain other sets of file or directory attribute information. - Currently, GetFileAttributesEx retrieves a set of standard attributes that is a superset of the file system attribute - information. - When the GetFileAttributesEx function is called on a directory that is a mounted folder, it returns the attributes of the directory, - not those of the root directory in the volume that the mounted folder associates with the directory. To obtain the attributes of - the associated volume, call GetVolumeNameForVolumeMountPoint to obtain the name of the associated volume. Then use the resulting - name in a call to GetFileAttributesEx. The results are the attributes of the root directory on the associated volume. - Symbolic link behavior: If the path points to a symbolic link, the function returns attributes for the symbolic link. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves attributes for a specified file or directory. - - The GetFileAttributes function retrieves file system attribute information. - GetFileAttributesEx can obtain other sets of file or directory attribute information. - - Currently, GetFileAttributesEx retrieves a set of standard attributes that is a superset of the file system attribute information. - When the GetFileAttributesEx function is called on a directory that is a mounted folder, it returns the attributes of the directory, - not those of the root directory in the volume that the mounted folder associates with the directory. To obtain the attributes of - the associated volume, call GetVolumeNameForVolumeMountPoint to obtain the name of the associated volume. Then use the resulting - name in a call to GetFileAttributesEx. The results are the attributes of the root directory on the associated volume. - Symbolic link behavior: If the path points to a symbolic link, the function returns attributes for the symbolic link. - Transacted Operations - If a file is open for modification in a transaction, no other thread can open the file for modification until the transaction - is committed. Conversely, if a file is open for modification outside of a transaction, no transacted thread can open the file for - modification until the non-transacted handle is closed. If a non-transacted thread has a handle opened to modify a file, a call to - GetFileAttributesTransacted for that file will fail with an ERROR_TRANSACTIONAL_CONFLICT error. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves file information for the specified file. - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - Depending on the underlying network features of the operating system and the type of server connected to, - the GetFileInformationByHandle function may fail, return partial information, or full information for the given file. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves file information for the specified file. - - - Minimum supported client: Windows Vista [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2008 [desktop apps | Windows Store apps] - Redistributable: Windows SDK on Windows Server 2003 and Windows XP. - - The file. - The file information by handle class. - Information describing the file. - Size of the buffer. - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the - lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves file information for the specified file. - - Minimum supported client: Windows Vista [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2008 [desktop apps | Windows Store apps] - Redistributable: Windows SDK on Windows Server 2003 and Windows XP. - - - If the function succeeds, the return value is nonzero and file information data is contained in the buffer pointed to by the - lpByHandleFileInformation parameter. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - The file. - The file information by handle class. - Information describing the file. - Size of the buffer. - - - - Retrieves the size of the specified file. - - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves the final path for the specified file. - Minimum supported client: Windows Vista [desktop apps only]. - Minimum supported server: Windows Server 2008 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Checks whether the specified address is within a memory-mapped file in the address space of the specified process. If so, the - function returns the name of the memory-mapped file. - - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Locks the specified file for exclusive access by the calling process. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero (TRUE). If the function fails, the return value is zero (FALSE). To get - extended error information, call GetLastError. - - - - Maps a view of a file mapping into the address space of a calling process. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is the starting address of the mapped view. If the function fails, the return value is - . - - - - - Moves a file or directory, including its children. - You can provide a callback function that receives progress notifications. - - - The MoveFileWithProgress function coordinates its operation with the link tracking service, so link sources can be tracked as they are moved. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Filename of the existing file. - Filename of the new file. - The progress routine. - The data. - The flags. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Moves an existing file or a directory, including its children, as a transacted operation. - You can provide a callback function that receives progress notifications. - - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - An application-defined callback function used with the CopyFileEx, MoveFileTransacted, and MoveFileWithProgress functions. - It is called when a portion of a copy or move operation is completed. - The LPPROGRESS_ROUTINE type defines a pointer to this callback function. - NativeCopyMoveProgressRoutine (NativeCopyMoveProgressRoutine) is a placeholder for the application-defined function name. - - - - Replaces one file with another file, with the option of creating a backup copy of the original file. The replacement file assumes the name of the replaced file and its identity. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Sets the attributes for a file or directory. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Sets the attributes for a file or directory as a transacted operation. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Sets the date and time that the specified file or directory was created, last accessed, or last modified. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Unlocks a region in an open file. Unlocking a region enables other processes to access the region. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Unmaps a mapped view of a file from the calling process's address space. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - The base address. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Retrieves information about the specified disk, including the amount of free space on the disk. - - - Symbolic link behavior: If the path points to a symbolic link, the operation is performed on the target. - If this parameter is a UNC name, it must include a trailing backslash (for example, "\\MyServer\MyShare\"). - Furthermore, a drive specification must have a trailing backslash (for example, "C:\"). - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Full pathname of the root file. - [out] The sectors per cluster. - [out] The bytes per sector. - [out] Number of free clusters. - [out] The total number of clusters. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, - the total amount of free space, and the total amount of free space available to the user that is associated with the calling - thread. - - - Symbolic link behavior: If the path points to a symbolic link, the operation is performed on the target. - The GetDiskFreeSpaceEx function returns zero (0) for lpTotalNumberOfFreeBytes and lpFreeBytesAvailable - for all CD requests unless the disk is an unwritten CD in a CD-RW drive. - If this parameter is a UNC name, it must include a trailing backslash, for example, "\\MyServer\MyShare\". - This parameter does not have to specify the root directory on a disk. - The function accepts any directory on a disk. - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Pathname of the directory. - [out] The free bytes available. - [out] The total number of in bytes. - [out] The total number of free in bytes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - - - - - Creates a new directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - - - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - An application can obtain a handle to a directory by calling with the FILE_FLAG_BACKUP_SEMANTICS - flag set. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Full pathname of the file. - The security attributes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Creates a new directory with the attributes of a specified template directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - The CreateDirectoryEx function allows you to create directories that inherit stream information from other directories. - This function is useful, for example, when you are using Macintosh directories, which have a resource stream - that is needed to properly identify directory contents as an attribute. - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - You can obtain a handle to a directory by calling the function with the FILE_FLAG_BACKUP_SEMANTICS - flag set. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Pathname of the template directory. - Full pathname of the file. - The security attributes. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - - - - - Creates a new directory as a transacted operation, with the attributes of a specified template directory. - If the underlying file system supports security on files and directories, - the function applies a specified security descriptor to the new directory. - The new directory retains the other attributes of the specified template directory. - - - The CreateDirectoryTransacted function allows you to create directories that inherit stream information from other - directories. - This function is useful, for example, when you are using Macintosh directories, which have a resource stream - that is needed to properly identify directory contents as an attribute. - Some file systems, such as the NTFS file system, support compression or encryption for individual files and - directories. - On volumes formatted for such a file system, a new directory inherits the compression and encryption attributes of its parent - directory. - You can obtain a handle to a directory by calling the function with the - FILE_FLAG_BACKUP_SEMANTICS flag set. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Pathname of the template directory. - Pathname of the new directory. - The security attributes. - The transaction. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero (0). To get extended error information, call GetLastError. - This function fails with ERROR_EFS_NOT_ALLOWED_IN_TRANSACTION if you try to create a - child directory with a parent directory that has encryption disabled. - - - - - Retrieves the current directory for the current process. - - - The RemoveDirectory function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - The length of the buffer for the current directory string, in TCHARs. The buffer length must include room for a terminating null character. - - A pointer to the buffer that receives the current directory string. This null-terminated string specifies the absolute path to the current directory. - To determine the required buffer size, set this parameter to NULL and the nBufferLength parameter to 0. - - - If the function succeeds, the return value specifies the number of characters that are written to the buffer, not including the terminating null character. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Deletes an existing empty directory. - - - The RemoveDirectory function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - Full pathname of the file. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Deletes an existing empty directory as a transacted operation. - - - The RemoveDirectoryTransacted function marks a directory for deletion on close. - Therefore, the directory is not removed until the last handle to the directory is closed. - RemoveDirectory removes a directory junction, even if the contents of the target are not empty; - the function removes directory junctions regardless of the state of the target object. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - Full pathname of the file. - The transaction. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Changes the current directory for the current process. - - - The path to the new current directory. This parameter may specify a relative path or a full path. In either case, the full path of the specified directory is calculated and stored as the current directory. - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - The CM_Connect_Machine function creates a connection to a remote machine. - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - Available in Microsoft Windows 2000 and later versions of Windows. - - Name of the unc server. - [out] The ph machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Get_Device_ID_Ex function retrieves the device instance ID for a specified device instance on a local or a remote machine. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. -   - Available in Microsoft Windows 2000 and later versions of Windows. - - The dn development instance. - The buffer. - Length of the buffer. - The ul flags. - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Disconnect_Machine function removes a connection to a remote machine. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - SetLastError is set to . - Available in Microsoft Windows 2000 and later versions of Windows. - - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - - The CM_Get_Parent_Ex function obtains a device instance handle to the parent node of a specified device node (devnode) in a local - or a remote machine's device tree. - - - Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. - You cannot access remote machines when running on these versions of Windows. - Available in Microsoft Windows 2000 and later versions of Windows. - - [out] The pdn development instance. - The dn development instance. - The ul flags. - The machine. - - If the operation succeeds, the function returns CR_SUCCESS. - Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. - - - - Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. - - If the operation completes successfully, the return value is nonzero. - If the operation fails or is pending, the return value is zero. To get extended error information, call GetLastError. - - - To retrieve a handle to the device, you must call the function with either the name of a device or - the name of the driver associated with a device. - To specify a device name, use the following format: \\.\DeviceName - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - The device. - The i/o control code. - Buffer for in data. - Size of the in buffer. - Buffer for out data. - Size of the out buffer. - [out] The bytes returned. - The overlapped. - - - Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. - - If the operation completes successfully, the return value is nonzero. - If the operation fails or is pending, the return value is zero. To get extended error information, call GetLastError. - - - To retrieve a handle to the device, you must call the function with either the name of a device or - the name of the driver associated with a device. - To specify a device name, use the following format: \\.\DeviceName - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - The device. - The i/o control code. - Buffer for in data. - Size of the in buffer. - Buffer for out data. - Size of the out buffer. - [out] The bytes returned. - The overlapped. - - - - The SetupDiDestroyDeviceInfoList function deletes a device information set and frees all associated memory. - - - SetLastError is set to . - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - - The function returns TRUE if it is successful. - Otherwise, it returns FALSE and the logged error can be retrieved with a call to GetLastError. - - - - - The SetupDiEnumDeviceInterfaces function enumerates the device interfaces that are contained in a device information set. - - - Repeated calls to this function return an structure for a different device - interface. - This function can be called repeatedly to get information about interfaces in a device information set that are - associated - with a particular device information element or that are associated with all device information elements. - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - Information describing the development. - [in,out] Unique identifier for the interface class. - Zero-based index of the member. - [in,out] Information describing the device interface. - - SetupDiEnumDeviceInterfaces returns TRUE if the function completed without error. - If the function completed with an error, FALSE is returned and the error code for the failure can be retrieved by calling - GetLastError. - - - - - The SetupDiGetClassDevsEx function returns a handle to a device information set that contains requested device information elements - for a local or a remote computer. - - - The caller of SetupDiGetClassDevsEx must delete the returned device information set when it is no longer needed by calling - . - Available in Microsoft Windows 2000 and later versions of Windows. - - [in,out] Unique identifier for the class. - The enumerator. - The parent. - The devs ex flags. - Set the device information belongs to. - Name of the machine. - The reserved. - - If the operation succeeds, SetupDiGetClassDevsEx returns a handle to a device information set that contains all installed - devices that matched the supplied parameters. - If the operation fails, the function returns INVALID_HANDLE_VALUE. To get extended error information, call - GetLastError. - - - - - The SetupDiGetDeviceInterfaceDetail function returns details about a device interface. - - - The interface detail returned by this function consists of a device path that can be passed to Win32 functions such as - CreateFile. - Do not attempt to parse the device path symbolic name. The device path can be reused across system starts. - Available in Microsoft Windows 2000 and later versions of Windows. - - Information describing the development. - [in,out] Information describing the device interface. - [in,out] Information describing the device interface detail. - Size of the device interface detail data. - Size of the required. - [in,out] Information describing the device information. - - SetupDiGetDeviceInterfaceDetail returns TRUE if the function completed without error. - If the function completed with an error, FALSE is returned and the error code for the failure can be retrieved by calling - GetLastError. - - - - - The SetupDiGetDeviceRegistryProperty function retrieves a specified Plug and Play device property. - - Available in Microsoft Windows 2000 and later versions of Windows. - Set the device information belongs to. - [in,out] Information describing the device information. - The property. - [out] Type of the property register data. - Buffer for property data. - Size of the property buffer. - Size of the required. - - SetupDiGetDeviceRegistryProperty returns TRUE if the call was successful. - Otherwise, it returns FALSE and the logged error can be retrieved by making a call to GetLastError. - SetupDiGetDeviceRegistryProperty returns the ERROR_INVALID_DATA error code if the requested property does not exist for a - device or if the property data is not valid. - - - - The FindFirstFileEx function does not query the short file name, improving overall enumeration speed. -   - - The data is returned in a structure, - and cAlternateFileName member is always a NULL string. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - - - Uses a larger buffer for directory queries, which can increase performance of the find operation. - This value is not supported until Windows Server 2008 R2 and Windows 7. - - - DefaultFileBufferSize = 4096; Default type buffer size used for reading and writing files. - - - DefaultFileEncoding = Encoding.UTF8; Default type of Encoding used for reading and writing files. - - - MaxDirectoryLength = 255 - - - MaxPath = 260 - The specified path, file name, or both exceed the system-defined maximum length. - For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters. - - - - MaxPathUnicode = 32000 - - - When an exception is raised, bit shifting is needed to prevent: "System.OverflowException: Arithmetic operation resulted in an overflow." - - - The BackupRead function can be used to back up a file or directory, including the security information. - The function reads data associated with a specified file or directory into a buffer, - which can then be written to the backup medium using the WriteFile function. - - - This function is not intended for use in backing up files encrypted under the Encrypted File System. - Use ReadEncryptedFileRaw for that purpose. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The buffer. - Number of bytes to reads. - [out] Number of bytes reads. - true to abort. - true to process security. - [out] The context. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero, indicating that an I/O error occurred. To get extended error information, - call GetLastError. - - - - The BackupSeek function seeks forward in a data stream initially accessed by using the or - function. - The function reads data associated with a specified file or directory into a buffer, which can then be written to the backup - medium using the WriteFile function. - - - Applications use the BackupSeek function to skip portions of a data stream that cause errors. - This function does not seek across stream headers. For example, this function cannot be used to skip the stream name. - If an application attempts to seek past the end of a substream, the function fails, the lpdwLowByteSeeked and - lpdwHighByteSeeked parameters - indicate the actual number of bytes the function seeks, and the file position is placed at the start of the next stream - header. -   - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The low bytes to seek. - The high bytes to seek. - [out] The lpdw low bytes seeked. - [out] The lpdw high bytes seeked. - [out] The context. - - If the function could seek the requested amount, the function returns a nonzero value. - If the function could not seek the requested amount, the function returns zero. To get extended error information, call - GetLastError. - - - - The BackupWrite function can be used to restore a file or directory that was backed up using . - Use the ReadFile function to get a stream of data from the backup medium, then use BackupWrite to write the data to the - specified file or directory. -   - - - This function is not intended for use in restoring files encrypted under the Encrypted File System. Use WriteEncryptedFileRaw - for that purpose. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - The file. - The buffer. - Number of bytes to writes. - [out] Number of bytes writtens. - true to abort. - true to process security. - [out] The context. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero, indicating that an I/O error occurred. To get extended error information, - call GetLastError. - - - - Check is the current handle is not null, not closed and not invalid. - The current handle to check. - will throw an , will not raise this exception.. - on success, otherwise. - - - - Check is the current handle is not null, not closed and not invalid. - The current handle to check. - The result of Marshal.GetLastWin32Error() - will throw an , will not raise this exception.. - on success, otherwise. - - - - - Controls whether the system will handle the specified types of serious errors or whether the process will handle them. - - - Because the error mode is set for the entire process, you must ensure that multi-threaded applications do not set different error- - mode attributes. Doing so can lead to inconsistent error handling. - - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - The mode. - The return value is the previous state of the error-mode bit attributes. - - - - Controls whether the system will handle the specified types of serious errors or whether the calling thread will handle them. - - - Because the error mode is set for the entire process, you must ensure that multi-threaded applications do not set different error- - mode attributes. Doing so can lead to inconsistent error handling. - - Minimum supported client: Windows 7 [desktop apps only]. - Minimum supported server: Windows Server 2008 R2 [desktop apps only]. - The new mode. - [out] The old mode. - The return value is the previous state of the error-mode bit attributes. - - - Retrieves the full path and file name of the specified file or directory. - If the function fails for any other reason, the return value is zero. To get extended error information, call GetLastError. - The GetFullPathName function is not recommended for multithreaded applications or shared library code. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the full path and file name of the specified file or directory as a transacted operation. - If the function fails for any other reason, the return value is zero. To get extended error information, call GetLastError. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Converts the specified path to its long form. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Converts the specified path to its long form as a transacted operation. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Retrieves the short path form of the specified path. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Represents a wrapper class for a handle used by the SetupDiGetClassDevs/SetupDiDestroyDeviceInfoList Win32 API functions. - - - Initializes a new instance of the class. - - - Contains the basic information for a file. Used for file handles. - - Specifying -1 for , , or - indicates that operations on the current handle should not affect the given field. - (I.e, specifying -1 for will leave the unaffected by writes performed - on the current handle.) - - - - The time the file was created in format, - which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). - - - - The time the file was last accessed in format. - - - The time the file was last written to in format. - - - The time the file was changed in format. - - - The file attributes. - If this is set to 0 in a structure passed to SetFileInformationByHandle then none of the attributes are changed. - - - Contains information that the GetFileInformationByHandle function retrieves. - - - The file attributes. - - - A structure that specifies when a file or directory is created. - - - A structure. For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - - - - A structure. For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - - - The serial number of the volume that contains a file. - - - The high-order part of the file size. - - - The low-order part of the file size. - - - The number of links to this file. For the FAT file system this member is always 1. For the NTFS file system, it can be more than 1. - - - The high-order part of a unique identifier that is associated with a file. - - - The low-order part of a unique identifier that is associated with a file. - - - Controls whether the system will handle the specified types of serious errors or whether the process will handle them. - Minimum supported client: Windows 2000 Professional - Minimum supported server: Windows 2000 Server - - - ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups. - One of the values. - - - Contains information about files in the specified directory. Used for directory handles. Use only when calling GetFileInformationByHandleEx. - - The number of files that are returned for each call to GetFileInformationByHandleEx depends on the size of the buffer that is passed to the function. - Any subsequent calls to GetFileInformationByHandleEx on the same handle will resume the enumeration operation after the last file is returned. - - - - The offset for the next FILE_ID_BOTH_DIR_INFO structure that is returned. Contains zero (0) if no other entries follow this one. - - - The byte offset of the file within the parent directory. This member is undefined for file systems, such as NTFS, - in which the position of a file within the parent directory is not fixed and can be changed at any time to maintain sort order. - - - - The time that the file was created. - - - The time that the file was last accessed. - - - The time that the file was last written to. - - - The time that the file was last changed. - - - The absolute new end-of-file position as a byte offset from the start of the file to the end of the file. - Because this value is zero-based, it actually refers to the first free byte in the file. - In other words, EndOfFile is the offset to the byte that immediately follows the last valid byte in the file. - - - - The number of bytes that are allocated for the file. This value is usually a multiple of the sector or cluster size of the underlying physical device. - - - The file attributes. - - - The length of the file name. - - - The size of the extended attributes for the file. - - - The length of ShortName. - - - The short 8.3 file naming convention (for example, "FILENAME.TXT") name of the file. - - - The file ID. - - - The first character of the file name string. This is followed in memory by the remainder of the string. - - - Represents the number of 100-nanosecond intervals since January 1, 1601. This structure is a 64-bit value. - - - Converts a value to long. - - - Converts a value to long. - - - Determines whether the specified Object is equal to the current Object. - Another object to compare to. - if the specified Object is equal to the current Object; otherwise, . - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Implements the operator == - A. - B. - The result of the operator. - - - Implements the operator != - A. - B. - The result of the operator. - - - An SP_DEVINFO_DATA structure defines a device instance that is a member of a device information set. - - - The size, in bytes, of the SP_DEVINFO_DATA structure. - - - The GUID of the device's setup class. - - - An opaque handle to the device instance (also known as a handle to the devnode). - - - Reserved. For internal use only. - - - An SP_DEVICE_INTERFACE_DATA structure defines a device interface in a device information set. - - - The size, in bytes, of the SP_DEVICE_INTERFACE_DATA structure. - - - The GUID for the class to which the device interface belongs. - - - Can be one or more of the following: SPINT_ACTIVE (1), SPINT_DEFAULT (2), SPINT_REMOVED (3). - - - Reserved. Do not use. - - - An SP_DEVICE_INTERFACE_DETAIL_DATA structure contains the path for a device interface. - - - The size, in bytes, of the SP_DEVICE_INTERFACE_DETAIL_DATA structure. - - - The device interface path. This path can be passed to Win32 functions such as CreateFile. - - - WIN32_FILE_ATTRIBUTE_DATA structure contains attribute information for a file or directory. The GetFileAttributesEx function uses this structure. - - Not all file systems can record creation and last access time, and not all file systems record them in the same manner. - For example, on the FAT file system, create time has a resolution of 10 milliseconds, write time has a resolution of 2 seconds, - and access time has a resolution of 1 day. On the NTFS file system, access time has a resolution of 1 hour. - For more information, see File Times. - - - - The file attributes of a file. - - - A structure that specifies when a file or directory was created. - If the underlying file system does not support creation time, this member is zero. - - - A structure. - For a file, the structure specifies when the file was last read from, written to, or for executable files, run. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last access time, this member is zero. - On the FAT file system, the specified date for both files and directories is correct, but the time of day is always set to midnight. - - - - A structure. - For a file, the structure specifies when the file was last written to, truncated, or overwritten, for example, when WriteFile or SetEndOfFile are used. - The date and time are not updated when file attributes or security descriptors are changed. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last write time, this member is zero. - - - - The high-order DWORD of the file size. This member does not have a meaning for directories. - This value is zero unless the file size is greater than MAXDWORD. - The size of the file is equal to (nFileSizeHigh * (MAXDWORD+1)) + nFileSizeLow. - - - - The low-order DWORD of the file size. This member does not have a meaning for directories. - - - The file size. - - - Contains information about the file that is found by the FindFirstFile, FindFirstFileEx, or FindNextFile function. - - If a file has a long file name, the complete name appears in the cFileName member, and the 8.3 format truncated version of the name appears - in the cAlternateFileName member. Otherwise, cAlternateFileName is empty. If the FindFirstFileEx function was called with a value of FindExInfoBasic - in the fInfoLevelId parameter, the cAlternateFileName member will always contain a string value. This remains true for all subsequent calls to the - FindNextFile function. As an alternative method of retrieving the 8.3 format version of a file name, you can use the GetShortPathName function. - For more information about file names, see File Names, Paths, and Namespaces. - - - Not all file systems can record creation and last access times, and not all file systems record them in the same manner. - For example, on the FAT file system, create time has a resolution of 10 milliseconds, write time has a resolution of 2 seconds, - and access time has a resolution of 1 day. The NTFS file system delays updates to the last access time for a file by up to 1 hour - after the last access. For more information, see File Times. - - - - The file attributes of a file. - - - A structure that specifies when a file or directory was created. - If the underlying file system does not support creation time, this member is zero. - - - A structure. - For a file, the structure specifies when the file was last read from, written to, or for executable files, run. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last access time, this member is zero. - On the FAT file system, the specified date for both files and directories is correct, but the time of day is always set to midnight. - - - - A structure. - For a file, the structure specifies when the file was last written to, truncated, or overwritten, for example, when WriteFile or SetEndOfFile are used. - The date and time are not updated when file attributes or security descriptors are changed. - For a directory, the structure specifies when the directory is created. If the underlying file system does not support last write time, this member is zero. - - - - The high-order DWORD of the file size. This member does not have a meaning for directories. - This value is zero unless the file size is greater than MAXDWORD. - The size of the file is equal to (nFileSizeHigh * (MAXDWORD+1)) + nFileSizeLow. - - - - The low-order DWORD of the file size. This member does not have a meaning for directories. - - - If the dwFileAttributes member includes the FILE_ATTRIBUTE_REPARSE_POINT attribute, this member specifies the reparse point tag. - Otherwise, this value is undefined and should not be used. - - - - Reserved for future use. - - - The name of the file. - - - An alternative name for the file. This name is in the classic 8.3 file name format. - - - Contains stream data. - - - Type of stream data. - - - Attributes of data to facilitate cross-operating system transfer. - - - Size of data, in bytes. - - - Length of the name of the alternative data stream, in bytes. - - - Defines, redefines, or deletes MS-DOS device names. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Deletes a drive letter or mounted folder. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the name of a volume on a computer. FindFirstVolume is used to begin scanning the volumes of a computer. - - If the function succeeds, the return value is a search handle used in a subsequent call to the FindNextVolume and FindVolumeClose functions. - If the function fails to find any volumes, the return value is the INVALID_HANDLE_VALUE error code. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the name of a mounted folder on the specified volume. FindFirstVolumeMountPoint is used to begin scanning the mounted folders on a volume. - - If the function succeeds, the return value is a search handle used in a subsequent call to the FindNextVolumeMountPoint and FindVolumeMountPointClose functions. - If the function fails to find a mounted folder on the volume, the return value is the INVALID_HANDLE_VALUE error code. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Continues a volume search started by a call to the FindFirstVolume function. FindNextVolume finds one volume per call. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Continues a mounted folder search started by a call to the FindFirstVolumeMountPoint function. FindNextVolumeMountPoint finds one mounted folder per call. - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. If no more mounted folders can be found, the GetLastError function returns the ERROR_NO_MORE_FILES error code. - In that case, close the search with the FindVolumeMountPointClose function. - - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - Closes the specified volume search handle. - - SetLastError is set to . - Minimum supported client: Windows XP [desktop apps only]. Minimum supported server: Windows Server 2003 [desktop apps only]. - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Closes the specified mounted folder search handle. - - SetLastError is set to . - Minimum supported client: Windows XP - Minimum supported server: Windows Server 2003 - - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - - Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive. - To determine whether a drive is a USB-type drive, call and specify the - SPDRP_REMOVAL_POLICY property. - - - SMB does not support volume management functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - Full pathname of the root file. - - The return value specifies the type of drive, see . - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - - Retrieves a bitmask representing the currently available disk drives. - - - SMB does not support volume management functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is a bitmask representing the currently available disk drives. - Bit position 0 (the least-significant bit) is drive A, bit position 1 is drive B, bit position 2 is drive C, and so on. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves information about the file system and volume associated with the specified root directory. - - If all the requested information is retrieved, the return value is nonzero. - If not all the requested information is retrieved, the return value is zero. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - "lpRootPathName" must end with a trailing backslash. - - - Retrieves information about the file system and volume associated with the specified file. - - If all the requested information is retrieved, the return value is nonzero. - If not all the requested information is retrieved, the return value is zero. To get extended error information, call GetLastError. - - To retrieve the current compression state of a file or directory, use FSCTL_GET_COMPRESSION. - SMB does not support volume management functions. - Minimum supported client: Windows Vista [desktop apps only] - Minimum supported server: Windows Server 2008 [desktop apps only] - - - Retrieves a volume GUID path for the volume that is associated with the specified volume mount point (drive letter, volume GUID path, or mounted folder). - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Use GetVolumeNameForVolumeMountPoint to obtain a volume GUID path for use with functions such as SetVolumeMountPoint and FindFirstVolumeMountPoint that require a volume GUID path as an input parameter. - SMB does not support volume management functions. - Mount points aren't supported by ReFS volumes. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Retrieves the volume mount point where the specified path is mounted. - - If a specified path is passed, GetVolumePathName returns the path to the volume mount point, which means that it returns the - root of the volume where the end point of the specified path is located. - For example, assume that you have volume D mounted at C:\Mnt\Ddrive and volume E mounted at "C:\Mnt\Ddrive\Mnt\Edrive". Also - assume that you have a file with the path "E:\Dir\Subdir\MyFile". - If you pass "C:\Mnt\Ddrive\Mnt\Edrive\Dir\Subdir\MyFile" to GetVolumePathName, it returns the path "C:\Mnt\Ddrive\Mnt\Edrive\". - If a network share is specified, GetVolumePathName returns the shortest path for which GetDriveType returns DRIVE_REMOTE, - which means that the path is validated as a remote drive that exists, which the current user can access. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - If the function succeeds, the return value is nonzero. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - - - Retrieves a list of drive letters and mounted folder paths for the specified volume. - Minimum supported client: Windows XP. - Minimum supported server: Windows Server 2003. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Sets the label of a file system volume. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - "lpRootPathName" must end with a trailing backslash. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Associates a volume with a drive letter or a directory on another volume. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error - information, call GetLastError. - - - - Retrieves information about MS-DOS device names. - Minimum supported client: Windows XP [desktop apps only]. - Minimum supported server: Windows Server 2003 [desktop apps only]. - - If the function succeeds, the return value is the number of TCHARs stored into the buffer pointed to by lpTargetPath. If the - function fails, the return value is zero. To get extended error information, call GetLastError. If the buffer is too small, the - function fails and the last error code is ERROR_INSUFFICIENT_BUFFER. - - - - Indicates the format of a path passed to a method. - - At some point in code you know the full path of file system objects, e.g.: "C:\Windows". - For example, Directory.EnumerateFileSystemEntries() will return all files and directories from a given path. - Most likely, some processing will happen on the results of the enum. The file or directory may be passed - on to another function. Whenever a file path is required, some performance can be gained. -   - A path like: "C:\Windows" or "\\server\share" is considered a full path for a directory because it is rooted and has a drive/unc path. - If the method supports it, and will skip GetFullPath() - calls for path resolving of the object, while also avoiding path validation and checks. - Using (default) will always call GetFullPath() and perform path validation and checks. -   - When working in a loop with thousands of files, will give the best performance. - - - - The format of the path is automatically detected by the method and internally converted to an extended length path. - It can be either a standard (short) full path, an extended length (unicode) full path or a relative path. - Example relative path: "Windows". - - - - The path is a full path in either normal or extended length (UNICODE) format. - Internally it will be converted to an extended length (UNICODE) path. - Using this option has a very slight performance advantage compared to using . - Example full path: "C:\Windows" or "\\server\share". - - - - The path is an extended length path. No additional processing will be done on the path, and it will be used as is. - Using this option has a slight performance advantage compared to using . - Example long full path: "\\?\C:\Windows" or "\\?\UNC\server\share". - - - - The exception that is thrown when an attempt to create a directory or file that already exists was made. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The requested operation could not be completed because the device was not ready. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the directory is read-only. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the directory was not empty. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - The operation could not be completed because the file is read-only. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - Provides static methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of objects. - This class cannot be inherited. - - - - [AlphaFS] Calculates the hash/checksum for the given . - The name of the file. - One of the values. - - - [AlphaFS] Calculates the hash/checksum for the given . - The name of the file. - One of the values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - The name of the file. - One of the values. - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - The name of the file. - One of the values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Calculates the hash/checksum for the given . - The transaction. - One of the values. - The name of the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The file being backed up is not decrypted; it is backed up in its encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to export encrypted files. See - . - - - To backup an encrypted file call one of the - overloads and specify the file to backup - along with the destination stream of the backup data. - - - This function is intended for the backup of only encrypted files; see for backup - of unencrypted files. - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - - - - [AlphaFS] Backs up (export) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - The file being backed up is not decrypted; it is backed up in its encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to export encrypted files. See - . - - - To backup an encrypted file call one of the - overloads and specify the file to backup - along with the destination stream of the backup data. - - - This function is intended for the backup of only encrypted files; see for backup - of unencrypted files. - - - The name of the file to be backed up. - The destination stream to which the backup data will be written. - The path format of the parameter. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - The path format of the parameter. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - If set to a hidden file will be overwritten on import. - - - - [AlphaFS] Restores (import) encrypted files. This is one of a group of Encrypted File System (EFS) functions that is - intended to implement backup and restore functionality, while maintaining files in their encrypted state. - - - If the caller does not have access to the key for the file, the caller needs - to restore encrypted files. See - . - - - To restore an encrypted file call one of the - overloads and specify the file to restore - along with the destination stream of the restored data. - - - This function is intended for the restoration of only encrypted files; see for - backup of unencrypted files. - - - The stream to read previously backed up data from. - The path of the destination file to restore to. - If set to a hidden file will be overwritten on import. - The path format of the parameter. - - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The path to the file to enumerate streams of. - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The path to the file to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The transaction. - The path to the file to enumerate streams of. - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file. - The transaction. - The path to the file to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file. - - - [AlphaFS] Enumerates the streams of type :$DATA from the specified file or directory. - The transaction. - The path to the file or directory to enumerate streams of. - Indicates the format of the path parameter(s). - The streams of type :$DATA in the specified file or directory. - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The name of the file. - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - The transaction. - The name of the file. - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates an enumeration of all the hard links to the specified . - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - An enumerable collection of of all the hard links to the specified - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - - Several Exceptions possible. - - - Creates a symbolic link. - See to run this method in an elevated state. - The transaction. - The name of the target for the symbolic link to be created. - The symbolic link to be created. - Indicates whether the link target, , is a file or directory. - Indicates the format of the path parameter(s). - - Several Exceptions possible. - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only for files, not directories. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only for files, not directories. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, - and only for files, not directories. - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, - and only for files, not directories. - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - - - Establish a hard link between an existing file and a new file. This function - is only supported on the NTFS file system, and only for files, not directories. - - - The transaction. - The name of the new file. This parameter cannot specify the name of a directory. - The name of the existing file. This parameter cannot specify the name of a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - A path that describes a file to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - A path that describes a file to compress. - - - [AlphaFS] Compresses a file using NTFS compression. - The transaction. - A path that describes a file to compress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Compresses a file using NTFS compression. - The transaction. - A path that describes a file to compress. - - - [AlphaFS] Decompresses an NTFS compressed file. - A path that describes a file to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed file. - A path that describes a file to decompress. - - - [AlphaFS] Decompresses an NTFS compressed file. - The transaction. - A path that describes a file to decompress. - Indicates the format of the path parameter(s). - - - [AlphaFS] Decompresses an NTFS compressed file. - The transaction. - A path that describes a file to decompress. - - - Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - overrides the read only of the file. - - Indicates the format of the path parameter(s). - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - - The name of the file to be deleted. Wildcard characters are not supported. - - - overrides the read only of the file. - - - - - - - - [AlphaFS] Deletes the specified file. - If the file to be deleted does not exist, no exception is thrown. - The transaction. - - The name of the file to be deleted. Wildcard characters are not supported. - - - - - - - - [AlphaFS] Deletes the specified file. - The transaction. - The name of the file to be deleted. Wildcard characters are not supported. - overrides the read only of the file. - Indicates the format of the path parameter(s). - If the file to be deleted does not exist, no exception is thrown. - - - - - - - [AlphaFS] Deletes the specified file. - The transaction. - The name of the file to be deleted. Wildcard characters are not supported. - overrides the read only of the file. - If the file to be deleted does not exist, no exception is thrown. - - - - - - - Deletes a Non-/Transacted file. - If the file to be deleted does not exist, no exception is thrown. - - - - - The transaction. - The name of the file to be deleted. - overrides the read only of the file. - Indicates the format of the path parameter(s). - - - Decrypts a file that was encrypted by the current account using the Encrypt method. - A path that describes a file to decrypt. - - - [AlphaFS] Decrypts a file that was encrypted by the current account using the Encrypt method. - A path that describes a file to decrypt. - Indicates the format of the path parameter(s). - - - Encrypts a file so that only the account used to encrypt the file can decrypt it. - A path that describes a file to encrypt. - - - [AlphaFS] Encrypts a file so that only the account used to encrypt the file can decrypt it. - A path that describes a file to encrypt. - Indicates the format of the path parameter(s). - - - Decrypts/encrypts a file or directory so that only the account used to encrypt the file can decrypt it. - - Specifies that is a file or directory. - A path that describes a file to encrypt. - encrypt, decrypt. - Indicates the format of the path parameter(s). - - - Creates or opens a file for writing UTF-8 encoded text. - The file to be opened for writing. - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing UTF-8 encoded text. - The file to be opened for writing. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing encoded text. - The file to be opened for writing. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing UTF-8 encoded text. - The transaction. - The file to be opened for writing. - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - [AlphaFS] Creates or opens a file for writing encoded text. - The transaction. - The file to be opened for writing. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - A StreamWriter that writes to the specified file using UTF-8 encoding. - - - Creates or opens a file for writing encoded text. - The transaction. - The file to be opened for writing. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A that writes to the specified file using NativeMethods.DefaultFileBufferSize encoding. - - - Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory or an existing file. - - - Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory or an existing file. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is not allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. - - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - if the destination file should ignoring the read-only and hidden attributes and overwrite; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file. Overwriting a file of the same name is allowed. can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with details of the Copy action. - - Option is recommended for very large file transfers. - The attributes of the original file are retained in the copied file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - The transaction. - The file to copy. - The name of the destination file. This cannot be a directory. - that specify how the file is to be copied. This parameter can be . - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - - - - - - - - Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - A class with the status of the Move action. - - This method works across disk volumes, and it does not throw an exception if the source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an . - You cannot use the Move method to overwrite an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - - - - - - - The transaction. - The name of the file to move. - The new path for the file. - that specify how the file is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Determine the Copy or Move action. - - - Copy/move a Non-/Transacted file or directory including its children to a new location, or can be specified, - and the possibility of notifying the application of its progress through a callback function. - - A class with the status of the Copy or Move action. - - Option is recommended for very large file transfers. - You cannot use the Move method to overwrite an existing file, unless - contains . - This Move method works across disk volumes, and it does not throw an exception if the - source and destination are the same. - Note that if you attempt to replace a file by moving a file of the same name into - that directory, you get an IOException. - - - - - - - - - Specifies that and are a file or directory. - The transaction. - The source directory path. - The destination directory path. - if original Timestamps must be preserved, otherwise. This parameter is ignored for move operations. - that specify how the file is to be copied. This parameter can be . - Flags that specify how the file or directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the file has been copied/moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - The file to check. - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The file to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - - [AlphaFS] Determines whether the specified file is in use (locked). - Returns if the specified file is in use (locked); otherwise, - - - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - - Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - - - Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not - exist, this method creates a file, writes the specified lines to the file, and then closes - the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. - Therefore, the value of the path parameter must contain existing directories. - - - - - - - - - - - - - The file to append the lines to. The file is created if it doesn't already exist. - - The lines to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, writes the - specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends lines to a file, and then closes the file. If the specified file does not exist, this method creates a file, - writes the specified lines to the file, and then closes the file. - - - The method creates the file if it doesn't exist, but it doesn't create new directories. Therefore, the value of the path parameter - must contain existing directories. - - - - - - - - - - - - The transaction. - The file to append the lines to. The file is created if it doesn't already exist. - The lines to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - - - Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - The character to use. - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The file to append the specified string to. - The string to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - The character to use. - - - [AlphaFS] Appends the specified stringto the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Appends the specified string to the file, creating the file if it does not already exist. - - - - - - - - - - - The transaction. - The file to append the specified string to. - The string to append to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The file to write to. - The lines to write to the file. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - The file to write to. - The string array to write to the file. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The lines to write to the file. - The character to use. - - - Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - The character to use. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The file to write to. - The lines to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The lines to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The file to write to. - The string array to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - The character to use. - - - [AlphaFS] Creates a new file, writes a collection of strings to the file, and then closes the file. - The default behavior of the method is to write out data by using UTF-8 encoding without a byte order mark (BOM). - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The string array to write to the file. - The character to use. - Indicates the format of the path parameter(s). - - - Creates a new file, writes the specified string to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The file to write to. - The string to write to the file. - - - Creates a new file, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - - - [AlphaFS] Creates a new file, writes the specified string to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The file to write to. - The string to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The file to write to. - The string to write to the file. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file as part of a transaction, write the contents to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - - - [AlphaFS] Creates a new file as part of a transaction, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - - - [AlphaFS] Creates a new file as part of a transaction, write the contents to the file, and then closes the file. If the target file already exists, it is overwritten. - This method uses UTF-8 encoding without a Byte-Order Mark (BOM) - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Creates a new file as part of a transaction, writes the specified string to the file using the specified encoding, and then closes the file. If the target file already exists, it is overwritten. - - - - - - - - - - - The transaction. - The file to write to. - The string to write to the file. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - - - Creates/appends a new file by using the specified encoding, writes a collection of strings to the file, and then closes the file. - - - - - - - - - - - The transaction. - The file to write to. - The lines to write to the file. - The character to use. - for file Append, for file Write. - to a line terminator, to ommit the line terminator. - Indicates the format of the path parameter(s). - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or to a new - file if the specified file does not exist. - - The path to the file to append to. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The path to the file to append to. - The character to use. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or - to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - Creates a that appends NativeMethods.DefaultFileEncoding encoded text to an existing file, or to a new file if the specified file does not exist. - - The transaction. - The path to the file to append to. - The character to use. - Indicates the format of the path parameter(s). - - A stream writer that appends NativeMethods.DefaultFileEncoding encoded text to the specified file or to a new file. - - - - Creates or overwrites a file in the specified path. - The path and name of the file to create. - A that provides read/write access to the file specified in . - - - Creates or overwrites the specified file. - The name of the file. - The number of bytes buffered for reads and writes to the file. - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The path and name of the file to create. - Indicates the format of the path parameter(s). - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The name of the file. - The number of bytes buffered for reads and writes to the file. - Indicates the format of the path parameter(s). - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - One of the values that describes how to create or overwrite the - file. - - Indicates the format of the path parameter(s). - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - One of the values that describes how to create or overwrite the - file. - - - One of the values that determines the access control and audit - security for the file. - - Indicates the format of the path parameter(s). - - A new file with the specified buffer size, file options, and file security. - - - - Creates or overwrites a file in the specified path. - The transaction. - The path and name of the file to create. - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The transaction. - The name of the file. - - The number of bytes buffered for reads and writes to the file. - - - A with the specified buffer size that provides read/write access - to the file specified in . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The transaction. - The path and name of the file to create. - Indicates the format of the path parameter(s). - - A that provides read/write access to the file specified in - . - - - - Creates or overwrites the specified file. - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - Indicates the format of the path parameter(s). - - A with the specified buffer size that provides read/write access to the file specified in - . - - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - Indicates the format of the path parameter(s). - A new file with the specified buffer size. - - - - Creates or overwrites the specified file, specifying a buffer size and a - value that describes how to create or overwrite the file. - - The transaction. - The name of the file. - The number of bytes buffered for reads and writes to the file. - One of the values that describes how to create or overwrite the file. - - One of the values that determines the access control and audit security for the file. - - Indicates the format of the path parameter(s). - A new file with the specified buffer size, file options, and file security. - - - Creates or overwrites a file in the specified path. - The transaction. - The name of the file. - The additional advanced options to create a file. - - A instance that determines the access control and audit security for the file. - - The option gives you more precise control over how you want to create a file. - - The allow you additionally specify to default read/write capability - just write, bypassing any cache. - - - The option controls how you would like to share created file with other requesters. - - Indicates the format of the parameter. - The number of bytes buffered for reads and writes to the file. - A that provides read/write access to the file specified in path. - - - Creates or opens a file, directory or I/O device. - A that provides read/write access to the file or directory specified by . - - To obtain a directory handle using CreateFile, specify the FILE_FLAG_BACKUP_SEMANTICS flag as part of dwFlagsAndAttributes. - The most commonly used I/O devices are as follows: file, file stream, directory, physical disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. - - - - - The transaction. - The path and name of the file or directory to create. - One of the values that describes how to create or overwrite the file or directory. - A instance that determines the access control and audit security for the file or directory. - A constant that determines how to open or create the file or directory. - A constant that determines the access rights to use when creating access and audit rules for the file or directory. - A constant that determines how the file or directory will be shared by processes. - . - Indicates the format of the parameter. - - - Determines whether the specified file exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between the time you call the Exists method and perform another operation on the file, such as Delete. - - The file to check. - - Returns if the caller has the required permissions and - contains the name of an existing file; otherwise, - - - - - [AlphaFS] Determines whether the specified file exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, this method merely checks - if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between the time you call the Exists method and perform another operation on the file, such - as Delete. - - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions and - contains the name of an existing file; otherwise, - - - - - - [AlphaFS] Determines whether the specified file exists. - - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between - the time you call the Exists method and perform another operation on the file, such - as Delete. - - The transaction. - The file to check. - - Returns if the caller has the required permissions - and contains the name of an existing file; otherwise, - - - - - - [AlphaFS] Determines whether the specified file exists. - - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the - parameter before checking whether the directory exists. - The Exists method returns if any error occurs while trying to - determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with - invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the - file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in - between - the time you call the Exists method and perform another operation on the file, such - as Delete. - - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions - and contains the name of an existing file; otherwise, - - - - - Determines whether the specified file or directory exists. - - MSDN: .NET 3.5+: Trailing spaces are removed from the end of the parameter before checking whether - the directory exists. - The Exists method returns if any error occurs while trying to determine if the specified file - exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - - a failing or missing disk, or if the caller does not have permission to read the file. - The Exists method should not be used for path validation, - this method merely checks if the file specified in path exists. - Passing an invalid path to Exists returns false. - Be aware that another process can potentially do something with the file in between - the time you call the Exists method and perform another operation on the file, such as Delete. - - Specifies that is a file or directory. - The transaction. - The file to check. - Indicates the format of the path parameter(s). - - Returns if the caller has the required permissions - and contains the name of an existing file or directory; otherwise, - - - - Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - - - Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file. - A object that encapsulates the access control rules for the file described by the parameter. - - - - The path to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a file containing a object that describes the file's access control list (ACL) information. - - - [AlphaFS] Gets a object that encapsulates the access control list (ACL) entries for a specified file handle. - A object that encapsulates the access control rules for the file described by the parameter. - - - - A to a file containing a object that describes the file's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - - - [AlphaFS] Gets an object for a particular file or directory. - An object that encapsulates the access control rules for the file or directory described by the parameter. - - - - Generic type parameter. - Specifies that is a file or directory. - The path to a file/directory containing a / object that describes the file's/directory's access control list (ACL) information. - One (or more) of the values that specifies the type of access control list (ACL) information to receive. - Indicates the format of the path parameter(s). - - - Gets the of the file on the path. - The path to the file. - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The path to the file. - Indicates the format of the path parameter(s). - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The transaction. - The path to the file. - The of the file on the path. - - - [AlphaFS] Gets the of the file on the path. - The transaction. - The path to the file. - Indicates the format of the path parameter(s). - The of the file on the path. - - - Gets the or of the specified file or directory. - The or of the specified file or directory. - - - Generic type parameter. - The transaction. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - - - Calls NativeMethods.GetFileAttributesEx to retrieve WIN32_FILE_ATTRIBUTE_DATA. - Note that classes should use -1 as the uninitialized state for dataInitialized when relying on this method. - - No path (null, empty string) checking or normalization is performed. - . - . - [in,out]. - . - . - 0 on success, otherwise a Win32 error code. - - - Gets the creation date and time of the specified file. - The file for which to obtain creation date and time information. - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The transaction. - The file for which to obtain creation date and time information. - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - [AlphaFS] Gets the creation date and time of the specified file. - The transaction. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in - local time. - - - - Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - The transaction. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified file. - The transaction. - - The file for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file. This value is expressed in UTC - time. - - - - - [AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) or local time, of the specified file or directory. - - The transaction. - The file or directory for which to obtain creation date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the creation date and time for the specified file or directory. Depending on - this value is expressed in UTC- or local time. - - - - Gets the date and time that the specified file was last accessed. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in local time. - - - - Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to obtain access date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last accessed. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) or local time, that the specified file or directory was last - accessed. - - The transaction. - The file or directory for which to obtain access date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file or directory was last accessed. - Depending on this value is expressed in UTC- or local time. - - - - Gets the date and time that the specified file was last written to. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The transaction. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - [AlphaFS] Gets the date and time that the specified file was last written to. - The transaction. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in local time. - - - - Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The transaction. - The file for which to obtain write date and time information. - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified file was last written to. - - The transaction. - The file for which to obtain write date and time information. - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file was last written to. This value is - expressed in UTC time. - - - - - [AlphaFS] Gets the date and time, in coordinated universal time (UTC) or local time, that the specified file or directory was last - written to. - - The transaction. - The file or directory for which to obtain write date and time information. - - gets the Coordinated Universal Time (UTC), gets the local time. - - Indicates the format of the path parameter(s). - - A structure set to the date and time that the specified file or directory was last written to. - Depending on this value is expressed in UTC- or local time. - - - - Opens a on the specified path with read/write access. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A opened in the specified mode and path, with read/write access and not shared. - - - Opens a on the specified path, with the specified mode and access. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - An unshared that provides access to the specified file, with the specified mode and access. - - - Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - A on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - - - [AlphaFS] Opens a on the specified path with read/write access. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - Indicates the format of the path parameter(s). - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] Opens a on the specified path, with the specified mode and access. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - Indicates the format of the path parameter(s). - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - The extended attributes. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path with read/write access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] (Transacted) Opens a on the specified path with read/write access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - Indicates the format of the path parameter(s). - A opened in the specified mode and path, with read/write access and not shared. - - - [AlphaFS] (Transacted) Opens a on the specified path, with the specified mode and access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path, with the specified mode and access. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - Indicates the format of the path parameter(s). - - An unshared that provides access to the specified file, with the specified mode and access. - - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Indicates the format of the path parameter(s). - A on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - - - [AlphaFS] (Transacted) Opens a on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option. - The transaction. - The file to open. - - A value that specifies whether a file is created if one does not exist, and determines whether the contents - of existing files are retained or overwritten. - - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - The extended attributes. - Indicates the format of the path parameter(s). - - A on the specified path, having the specified mode with read, write, or read/write access and the - specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the - underlying operating system might not support asynchronous I/O, so when specifying true, the handle might be - opened synchronously depending on the platform. When opened asynchronously, the BeginRead and BeginWrite methods - perform better on large reads or writes, but they might be much slower for small reads or writes. If the - application is designed to take advantage of asynchronous I/O, set the useAsync parameter to true. Using - asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without - redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - The extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, read/write and sharing permission, and buffer size. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - A value that specifies additional file options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] (Transacted) Opens a on the specified path using the specified creation mode, access rights and sharing permission, the buffer size, additional file options, access control and audit security. - The transaction. - The file to open. - A constant that determines how to open or create the file. - A value that specifies the operations that can be performed on the - file. - A constant that determines how the file will be shared by processes. - A positive value greater than 0 indicating the buffer size. The - default buffer size is 4096. - Extended attributes specifying additional options. - A value that determines the access control and audit security for the file. - Indicates the format of the path parameter. - - A on the specified path, having the specified mode with read, write, or read/write - access and the specified sharing option. - - - - [AlphaFS] Opens a on the specified path, having the specified mode with read, write, or read/write access, the specified sharing option and additional options specified. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies the operations that can be performed on the file. - A value specifying the type of access other threads have to the file. - Advanced options for this file. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - The security. - Indicates the format of the path parameter(s). - - A instance on the specified path, having the specified mode with - read, write, or read/write access and the specified sharing option. - - - - Opens a on the specified path, having the specified mode with read, write, or read/write access, the specified sharing option and additional options specified. - The transaction. - The file to open. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - A value specifying the type of access other threads have to the file. - Advanced options for this file. - A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. - The security. - Indicates the format of the path parameter(s). - - A instance on the specified path, having the specified mode with - read, write, or read/write access and the specified sharing option. - - - - Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The file to open for reading. - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The transaction. - The file to open for reading. - A byte array containing the contents of the file. - - - [AlphaFS] Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - Opens a binary file, reads the contents of the file into a byte array, and then closes the file. - - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - A byte array containing the contents of the file. - - - Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - All lines of the file. - - - Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Opens a file, read all lines of the file with the specified encoding, and then close the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - An IEnumerable string containing all lines of the file. - - - Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - All lines of the file. - - - Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - All lines of the file. - - - [AlphaFS] Opens a text file, reads all lines of the file, and then closes the file. - The transaction. - The file to open for reading. - Indicates the format of the path parameter(s). - All lines of the file. - - - [AlphaFS] Opens a file, reads all lines of the file with the specified encoding, and then closes the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Open a file, read all lines of the file with the specified encoding, and then close the file. - The transaction. - The file to open for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - All lines of the file. - - - Reads the lines of a file. - The file to read. - All the lines of the file, or the lines that are the result of a query. - - - Read the lines of a file that has a specified encoding. - The file to read. - The encoding that is applied to the contents of the file. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The file to read. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The transaction. - The file to read. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Reads the lines of a file. - The transaction. - The file to read. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - [AlphaFS] Read the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - Reads the lines of a file that has a specified encoding. - The transaction. - The file to read. - The encoding that is applied to the contents of the file. - Indicates the format of the path parameter(s). - All the lines of the file, or the lines that are the result of a query. - - - - Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a backup of - the replaced file. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - - - Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a backup of - the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - - - - [AlphaFS] Replaces the contents of a specified file with the contents of another file, deleting the original file, and creating a - backup of the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - Indicates the format of the path parameter(s). - - - Replaces the contents of a specified file with the contents of another file, deleting - the original file, and creating a backup of the replaced file and optionally ignores merge errors. - - - The Replace method replaces the contents of a specified file with the contents of another file. It also creates a backup of the - file that was replaced. - - - If the and are on different volumes, this method will - raise an exception. If the is on a different volume from the source file, the backup - file will be deleted. - - - Pass null to the parameter if you do not want to create a backup of the file being - replaced. - - The name of a file that replaces the file specified by . - The name of the file being replaced. - The name of the backup file. - - to ignore merge errors (such as attributes and access control lists (ACLs)) from the replaced file to the - replacement file; otherwise, . - - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - - - Applies access control list (ACL) entries described by a object to the specified directory. - - - - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Applies access control list (ACL) entries described by a object to the specified directory. - - - - A directory to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the directory described by the path parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - - - Applies access control list (ACL) entries described by a FileSecurity object to the specified file. - - - - A to a file to add or remove access control list (ACL) entries from. - A object that describes an ACL entry to apply to the file described by the parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - [AlphaFS] Applies access control list (ACL) entries described by a / object to the specified file or directory. - Use either or , not both. - - - - A file/directory to add or remove access control list (ACL) entries from. This parameter This parameter may be . - A to add or remove access control list (ACL) entries from. This parameter This parameter may be . - A / object that describes an ACL entry to apply to the file/directory described by the / parameter. - One or more of the values that specifies the type of access control list (ACL) information to set. - Indicates the format of the path parameter(s). - - - Sets the specified of the file or directory on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The path to the file or directory. - A bitwise combination of the enumeration values. - Sets the specified of the file or directory on the specified path. - - - [AlphaFS] Sets the specified of the file or directory on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The path to the file or directory. - A bitwise combination of the enumeration values. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the specified of the file on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The transaction. - The path to the file. - A bitwise combination of the enumeration values. - - - [AlphaFS] Sets the specified of the file on the specified path. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using this method. - - The transaction. - The path to the file. - A bitwise combination of the enumeration values. - Indicates the format of the path parameter(s). - - - Sets the attributes for a Non-/Transacted file/directory. - - Certain file attributes, such as and , can be combined. - Other attributes, such as , must be used alone. - - - It is not possible to change the status of a File object using the SetAttributes method. - - - Specifies that is a file or directory. - The transaction. - The name of the file or directory whose attributes are to be set. - - The attributes to set for the file or directory. Note that all other values override . - - - does not throw an Exception when the file system object does not exist. - - Indicates the format of the path parameter(s). - - - Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the file was created. - The transaction. - The file for which to set the creation date and time information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last accessed. - The transaction. - The file for which to set the access date and time information. - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets the date and time that the specified file was last written to. - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - - [AlphaFS] Sets the date and time, in coordinated universal time (UTC), that the specified file was last written to. - - The transaction. - The file for which to set the date and time information. - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - - - [AlphaFS] Sets all the date and time stamps for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in local time. - - - A containing the value to set for the last access date and time of . This - value is expressed in local time. - - - A containing the value to set for the last write date and time of . This value - is expressed in local time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - - - [AlphaFS] Sets all the date and time stamps, in coordinated universal time (UTC), for the specified file, at once. - The transaction. - The file for which to set the dates and times information. - - A containing the value to set for the creation date and time of . This value - is expressed in UTC time. - - - A containing the value to set for the last access date and time of . This - value is expressed in UTC time. - - - A containing the value to set for the last write date and time of . This value - is expressed in UTC time. - - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - Set the date and time, in coordinated universal time (UTC), that the file or directory was created and/or last accessed and/or written to. - - - Specifies that is a file or directory. - The transaction. - The file or directory for which to set the date and time information. - A containing the value to set for the creation date and time of . This value is expressed in UTC time. - A containing the value to set for the last access date and time of . This value is expressed in UTC time. - A containing the value to set for the last write date and time of . This value is expressed in UTC time. - If , the date and time information will apply to the reparse point (symlink or junction) and not the file or directory linked to. No effect if does not refer to a reparse point. - Indicates the format of the path parameter(s). - - - - Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already exists, it is - overwritten. - - The file to write to. - The bytes to write to the file. - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The transaction. - The file to write to. - The bytes to write to the file. - - - - [AlphaFS] Creates a new file, writes the specified byte array to the file, and then closes the file. If the target file already - exists, it is overwritten. - - The transaction. - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - Creates a new file as part of a transaction, writes the specified byte array to - the file, and then closes the file. If the target file already exists, it is overwritten. - - - The transaction. - The file to write to. - The bytes to write to the file. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The file for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - An open handle to the file or directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The transaction. - The file for which to obtain creation date and time information. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - The transaction. - The file for which to obtain creation date and time information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - An open handle to the file or directory from which to retrieve information. - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in UTC time. - The transaction. - The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format. - - - Gets the change date and time of the specified file. - A structure set to the change date and time for the specified file. This value is expressed in local time. - Use either or , not both. - - - - Specifies that is a file or directory. - The transaction. - An open handle to the file or directory from which to retrieve information. - The file or directory for which to obtain creation date and time information. - gets the Coordinated Universal Time (UTC), gets the local time. - Indicates the format of the path parameter(s). - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file. - - If the file is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size - of the specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value - obtained is the sparse size of the specified file. - - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file. - - If the file is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size - of the specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value - obtained is the sparse size of the specified file. - - The name of the file. - The actual number of bytes of disk storage used to store the specified file. - - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file as part of a transaction. If the file - is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size of the - specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value obtained is - the sparse size of the specified file. - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - - [AlphaFS] Retrieves the actual number of bytes of disk storage used to store a specified file as part of a transaction. If the file - is located on a volume that supports compression and the file is compressed, the value obtained is the compressed size of the - specified file. If the file is located on a volume that supports sparse files and the file is a sparse file, the value obtained is - the sparse size of the specified file. - - The transaction. - The name of the file. - The actual number of bytes of disk storage used to store the specified file. - - - Retrieves the actual number of bytes of disk storage used to store a - specified file as part of a transaction. If the file is located on a volume that supports compression and the file is compressed, - the value obtained is the compressed size of the specified file. If the file is located on a volume that supports sparse files and - the file is a sparse file, the value obtained is the sparse size of the specified file. - - - The transaction. - The name of the file. - Indicates the format of the path parameter(s). - The actual number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the encryption status of the specified file. - The name of the file. - Indicates the format of the path parameter(s). - The of the specified . - - - [AlphaFS] Retrieves the encryption status of the specified file. - The name of the file. - The of the specified . - - - Retrieves the encryption status of the specified file. - The name of the file. - Indicates the format of the path parameter(s). - The of the specified . - - - [AlphaFS] Retrieves file information for the specified . - A connected to the open file from which to retrieve the information. - A object containing the requested information. - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The path to the file or directory. - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The transaction. - The path to the file or directory. - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets the of the file on the path. - The instance of the file or directory. - The transaction. - The path to the file or directory. - - - Gets a FileSystemEntryInfo from a Non-/Transacted directory/file. - The instance of the file or directory, or null on Exception when is true. - BasicSearch and LargeCache are used by default, if possible. - - - Specifies that is a file or directory. - The transaction. - The path to the file or directory. - - true suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - Indicates the format of the path parameter(s). - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The path to the reparse point. - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - Gets information about the target of a mount point or symbolic link on an NTFS file system. - The transaction. - The path to the reparse point. - Indicates the format of the path parameter(s). - - An instance of or containing information about the symbolic link - or mount point pointed to by . - - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The path to the file. - Indicates the format of the path parameter(s). - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The path to the file. - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The to the file. - The file size, in bytes. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The transaction. - The path to the file. - Indicates the format of the path parameter(s). - The number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Retrieves the file size, in bytes to store a specified file. - The transaction. - The path to the file. - The number of bytes of disk storage used to store the specified file. - - - Retrieves the file size, in bytes to store a specified file. - Use either or , not both. - The transaction. - The to the file. - The path to the file. - Indicates the format of the path parameter(s). - The number of bytes of disk storage used to store the specified file. - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The transaction. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - Indicates the format of the path parameter(s). - - - [AlphaFS] Transfers the date and time stamps for the specified files. - This method does not change last access time for the source file. - The transaction. - The source file to get the date and time stamps from. - The destination file to set the date and time stamps. - - - Transfer the date and time stamps for the specified files and directories. - - This method does not change last access time for the source file. - This method uses BackupSemantics flag to get Timestamp changed for directories. - - Specifies that and are a file or directory. - The transaction. - The source path. - The destination path. - Indicates the format of the path parameter(s). - - - Opens an existing file for reading. - The file to be opened for reading. - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The transaction. - The file to be opened for reading. - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - [AlphaFS] Opens an existing file for reading. - The transaction. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A read-only on the specified path. - - This method is equivalent to the (string, FileMode, FileAccess, FileShare) constructor overload with a - value of Open, a value of Read and a value of Read. - - - - Opens an existing UTF-8 encoded text file for reading. - The file to be opened for reading. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The file to be opened for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The file to be opened for reading. - The applied to the contents of the file. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The transaction. - The file to be opened for reading. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing UTF-8 encoded text file for reading. - The transaction. - The file to be opened for reading. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The transaction. - The file to be opened for reading. - The applied to the contents of the file. - Indicates the format of the path parameter(s). - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - [AlphaFS] Opens an existing encoded text file for reading. - The transaction. - The file to be opened for reading. - The applied to the contents of the file. - A on the specified path. - This method is equivalent to the (String) constructor overload. - - - Opens an existing file or creates a new file for writing. - The file to be opened for writing. - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The file to be opened for writing. - Indicates the format of the path parameter(s). - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The transaction. - The file to be opened for writing. - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens an existing file or creates a new file for writing. - The transaction. - The file to be opened for writing. - Indicates the format of the path parameter(s). - An unshared object on the specified path with access. - This method is equivalent to the (String, FileMode, FileAccess, FileShare) constructor overload with file mode set to OpenOrCreate, the access set to Write, and the share mode set to None. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The file path to open. - Indicates the format of the path parameter(s). - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. This method is simpler to use then BackupFileStream to read only file's data stream. - The file path to open. - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The transaction. - The file path to open. - Indicates the format of the path parameter(s). - A on the specified path, having the read-only mode and sharing options. - - - [AlphaFS] Opens the specified file for reading purposes bypassing security attributes. - The transaction. - The file path to open. - A on the specified path, having the read-only mode and sharing options. - - - Provides access to information of a device, on a local or remote host. - - - Initializes a DeviceInfo class. - - - Initializes a DeviceInfo class. - The DNS or NetBIOS name of the remote server. refers to the local host. - - - Enumerates all available devices on the local host. - One of the devices. - instances of type from the local host. - - - Represents the value of the base container identifier (ID) .The Windows Plug and Play (PnP) manager assigns this value to the device node (devnode). - - - Represents the name of the device setup class that a device instance belongs to. - - - Represents the of the device setup class that a device instance belongs to. - - - Represents the list of compatible identifiers for a device instance. - - - Represents a description of a device instance. - - - The device interface path. - - - Represents the registry entry name of the driver key for a device instance. - - - Represents the name of the enumerator for a device instance. - - - Represents the friendly name of a device instance. - - - Represents the list of hardware identifiers for a device instance. - - - The host name that was passed to the class constructor. - - - Gets the instance Id of the device. - - - Represents the bus-specific physical location of a device instance. - - - Represents the location of a device instance in the device tree. - - - Represents the name of the manufacturer of a device instance. - - - Encapsulates the physical device location information provided by a device's firmware to Windows. - - - Represents the name of the service that is installed for a device instance. - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, - the total amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - This class cannot be inherited. - - - - Initializes a DiskSpaceInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share - This is a Lazyloading object; call to populate all properties first before accessing. - - - Initializes a DiskSpaceInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share - gets both size- and disk cluster information. Get only disk cluster information, Get only size information. - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Refreshes the state of the object. - - - Initializes all properties to 0. - - - Returns the drive name. - A string that represents this object. - - - Indicates the amount of available free space on a drive, formatted as percentage. - - - Indicates the amount of available free space on a drive, formatted as a unit size. - - - Returns the Clusters size. - - - Gets the name of a drive. - The name of the drive. - This property is the name assigned to the drive, such as C:\ or E:\ - - - The total number of bytes on a disk that are available to the user who is associated with the calling thread, formatted as a unit size. - - - Indicates the amount of used space on a drive, formatted as percentage. - - - Indicates the amount of used space on a drive, formatted as a unit size. - - - The total number of free bytes on a disk that are available to the user who is associated with the calling thread. - - - The total number of bytes on a disk that are available to the user who is associated with the calling thread. - - - The total number of free bytes on a disk. - - - The number of bytes per sector. - - - The total number of free clusters on the disk that are available to the user who is associated with the calling thread. - - - The number of sectors per cluster. - - - The total number of clusters on the disk that are available to the user who is associated with the calling thread. - If per-user disk quotas are in use, this value may be less than the total number of clusters on the disk. - - - - Provides access to information on a local or remote drive. - - This class models a drive and provides methods and properties to query for drive information. - Use DriveInfo to determine what drives are available, and what type of drives they are. - You can also query to determine the capacity and available free space on the drive. - - - - Provides access to information on the specified drive. - - - - A valid drive path or drive letter. - This can be either uppercase or lowercase, - 'a' to 'z' or a network share in the format: \\server\share - - - - Indicates the amount of available free space on a drive. - The amount of free space available on the drive, in bytes. - This property indicates the amount of free space available on the drive. Note that this number may be different from the number because this property takes into account disk quotas. - - - Gets the name of the file system, such as NTFS or FAT32. - Use DriveFormat to determine what formatting a drive uses. - - - Gets the drive type. - One of the values. - - The DriveType property indicates whether a drive is any of: CDRom, Fixed, Unknown, Network, NoRootDirectory, - Ram, Removable, or Unknown. Values are listed in the enumeration. - - - - Gets a value indicating whether a drive is ready. - if the drive is ready; otherwise, . - - IsReady indicates whether a drive is ready. For example, it indicates whether a CD is in a CD drive or whether - a removable storage device is ready for read/write operations. If you do not test whether a drive is ready, and - it is not ready, querying the drive using DriveInfo will raise an IOException. - - Do not rely on IsReady() to avoid catching exceptions from other members such as TotalSize, TotalFreeSpace, and DriveFormat. - Between the time that your code checks IsReady and then accesses one of the other properties - (even if the access occurs immediately after the check), a drive may have been disconnected or a disk may have been removed. - - - - Gets the name of the drive. - The name of the drive. - This property is the name assigned to the drive, such as C:\ or E:\ - - - Gets the root directory of a drive. - A DirectoryInfo object that contains the root directory of the drive. - - - Gets the total amount of free space available on a drive. - The total free space available on a drive, in bytes. - This property indicates the total amount of free space available on the drive, not just what is available to the current user. - - - Gets the total size of storage space on a drive. - The total size of the drive, in bytes. - This property indicates the total size of the drive in bytes, not just what is available to the current user. - - - Gets or sets the volume label of a drive. - The volume label. - - The label length is determined by the operating system. For example, NTFS allows a volume label - to be up to 32 characters long. Note that is a valid VolumeLabel. - - - - [AlphaFS] Returns the instance. - - - [AlphaFS] The MS-DOS device name. - - - [AlphaFS] Indicates if this drive is a SUBST.EXE / DefineDosDevice drive mapping. - - - [AlphaFS] Indicates if this drive is a UNC path. - Only retrieve this information if we're dealing with a real network share mapping: http://alphafs.codeplex.com/discussions/316583 - - - [AlphaFS] Determines whether the specified volume name is a defined volume on the current computer. - - - [AlphaFS] Contains information about a file-system volume. - A VolumeInfo object that contains file-system volume information of the drive. - - - Retrieves the drive names of all logical drives on a computer. - An array of type that represents the logical drives on a computer. - - - Returns a drive name as a string. - The name of the drive. - This method returns the Name property. - - - [AlphaFS] Enumerates the drive names of all logical drives on a computer. - Retrieve logical drives as known by the Environment. - Retrieve only when accessible (IsReady) logical drives. - - An IEnumerable of type that represents - the logical drives on a computer. - - - - [AlphaFS] Gets the first available drive letter on the local system. - A drive letter as . When no drive letters are available, an exception is thrown. - The letters "A" and "B" are reserved for floppy drives and will never be returned by this function. - - - Gets an available drive letter on the local system. - When get the last available drive letter. When gets the first available drive letter. - A drive letter as . When no drive letters are available, an exception is thrown. - The letters "A" and "B" are reserved for floppy drives and will never be returned by this function. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - - - Used by CopyFileXxx and MoveFileXxx. The function should return one of the following values. - - - PROGRESS_CONTINUE - Continue the copy operation. - - - - PROGRESS_CANCEL - Cancel the copy operation and delete the destination file. - - - - PROGRESS_STOP - Stop the copy operation. It can be restarted at a later time. - - - - PROGRESS_QUIET - Continue the copy operation, but stop invoking to report progress. - - - - [AlphaFS] Directory enumeration options, flags that specify how a directory is to be enumerated. - - - None (do not use). - - - Enumerate files only. - - - Enumerate directories only. - - - Enumerate files and directories. - - - Return full path as long full path (Unicode format), only valid when return type is . - - - Skip reparse points during directory enumeration. - - - Suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - - - Specifies whether to search the current directory, or the current directory and all subdirectories. - - - Enumerates the directory without querying the short file name, improving overall enumeration speed. - This option is enabled by default if supported. This value is not supported until Windows Server 2008 R2 and Windows 7. - - - Enumerates the directory using a larger buffer for directory queries, which can increase performance of the find operation. - This option is enabled by default if supported. This value is not supported until Windows Server 2008 R2 and Windows 7. - - - System-Defined Device Interface Classes - http://msdn.microsoft.com/en-us/library/windows/hardware/ff541389%28v=vs.85%29.aspx - - - The BUS1394_CLASS_GUID device interface class is defined for 1394 bus devices. - - - The GUID_61883_CLASS device interface class is defined for devices in the 61883 device setup class. - - - The GUID_DEVICE_APPLICATIONLAUNCH_BUTTON device interface class is defined for Advanced Configuration and Power Interface (ACPI) application start buttons. - - - The GUID_DEVICE_BATTERY device interface class is defined for battery devices. - - - The GUID_DEVICE_LID device interface class is defined for Advanced Configuration and Power Interface (ACPI) lid devices. - - - The GUID_DEVICE_MEMORY device interface class is defined for Advanced Configuration and Power Interface (ACPI) memory devices. - - - The GUID_DEVICE_MESSAGE_INDICATOR device interface class is defined for Advanced Configuration and Power Interface (ACPI) message indicator devices. - - - The GUID_DEVICE_PROCESSOR device interface class is defined for Advanced Configuration and Power Interface (ACPI) processor devices. - - - The GUID_DEVICE_SYS_BUTTON device interface classis defined for Advanced Configuration and Power Interface (ACPI) system power button devices. - - - The GUID_DEVICE_THERMAL_ZONE device interface class is defined for Advanced Configuration and Power Interface (ACPI) thermal zone devices. - - - The GUID_BTHPORT_DEVICE_INTERFACE device interface class is defined for Bluetooth radios. - - - The GUID_DEVINTERFACE_BRIGHTNESS device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and support brightness control of monitor child devices. - - - The GUID_DEVINTERFACE_DISPLAY_ADAPTER device interface class is defined for display views that are supported by display adapters. - - - The GUID_DEVINTERFACE_I2C device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and perform I2C transactions with monitor child devices. - - - The GUID_DEVINTERFACE_IMAGE device interface class is defined for WIA devices and Still Image (STI) devices, including digital cameras and scanners. - - - The GUID_DEVINTERFACE_MONITOR device interface class is defined for monitor devices. - - - The GUID_DEVINTERFACE_OPM device interface class is defined for display adapter drivers that operate in the context of the Windows Vista Display Driver Model and support output protection management (OPM) for monitor child devices. - - - The GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL device interface class is defined for child devices of display devices. - - - The GUID_DISPLAY_DEVICE_ARRIVAL device interface class is defined for display adapters. - - - The GUID_DEVINTERFACE_HID device interface class is defined for HID collections. - - - The GUID_DEVINTERFACE_KEYBOARD device interface class is defined for keyboard devices. - - - The GUID_DEVINTERFACE_MOUSE device interface class is defined for mouse devices. - - - The GUID_DEVINTERFACE_MODEM device interface class is defined for modem devices. - - - The GUID_DEVINTERFACE_NET device interface class is defined for network devices. - - - The GUID_DEVINTERFACE_COMPORT device interface class is defined for COM ports. - - - The GUID_DEVINTERFACE_PARALLEL device interface class is defined for parallel ports that support an IEEE 1284-compatible hardware interface. - - - The GUID_DEVINTERFACE_PARCLASS device interface class is defined for devices that are attached to a parallel port. - - - The GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR device interface class is defined for Plug and Play (PnP) serial ports. - - - The GUID_DEVINTERFACE_CDCHANGER device interface class is defined for CD-ROM changer devices. - - - The GUID_DEVINTERFACE_CDROM device interface class is defined for CD-ROM storage devices. - - - The GUID_DEVINTERFACE_DISK device interface class is defined for hard disk storage devices. - - - The GUID_DEVINTERFACE_FLOPPY device interface class is defined for floppy disk storage devices. - - - The GUID_DEVINTERFACE_MEDIUMCHANGER device interface class is defined for medium changer devices. - - - The GUID_DEVINTERFACE_PARTITION device interface class is defined for partition devices. - - - The GUID_DEVINTERFACE_STORAGEPORT device interface class is defined for storage port devices. - - - The GUID_DEVINTERFACE_TAPE device interface class is defined for tape storage devices. - - - The GUID_DEVINTERFACE_VOLUME device interface class is defined for volume devices. - - - The GUID_DEVINTERFACE_WRITEONCEDISK device interface class is defined for write-once disk devices. - - - The GUID_DEVINTERFACE_USB_DEVICE device interface class is defined for USB devices that are attached to a USB hub. - - - The GUID_DEVINTERFACE_USB_HOST_CONTROLLER device interface class is defined for USB host controller devices. - - - The GUID_DEVINTERFACE_USB_HUB device interface class is defined for USB hub devices. - - - Defines the controllable aspects of the Volume.DefineDosDevice() method. - - - DDD_EXACT_MATCH_ON_REMOVE - Default. - - - - DDD_RAW_TARGET_PATH - Uses the targetPath string as is. Otherwise, it is converted from an MS-DOS path to a path. - - - - DDD_REMOVE_DEFINITION - Removes the specified definition for the specified device. - To determine which definition to remove, the function walks the list of mappings for the device, looking for a match of targetPath against a prefix of each mapping associated with this device. - The first mapping that matches is the one removed, and then the function returns. - If targetPath is null or a pointer to a null string, the function will remove the first mapping associated with the device and pop the most recent one pushed.If there is nothing left to pop, the device name will be removed. - If this value is not specified, the string pointed to by the targetPath parameter will become the new mapping for this device. - - - - DDD_EXACT_MATCH_ON_REMOVE - If this value is specified along with , the function will use an exact match to determine which mapping to remove. - Use this value to ensure that you do not delete something that you did not define. - - - - DDD_NO_BROADCAST_SYSTEM - Do not broadcast the WM_SETTINGCHANGE message. - By default, this message is broadcast to notify the shell and applications of the change. - - - - Determines the format to convert a path to using - - - (FileNameNormalized / VolumeNameDos) Return the normalized drive name. This is the default. - - - Return the path with a volume GUID path instead of the drive name. - - - Return the path with the volume device path. - - - Return the path with no drive information. - - - Return the opened file name (not normalized). - - - Enumeration specifying the different reparse point tags. - - Reparse tags, with the exception of IO_REPARSE_TAG_SYMLINK, are processed on the server and are not processed by a client after transmission over the wire. - Clients should treat associated reparse data as opaque data. - - - - The entry is not a reparse point. - - - IO_REPARSE_APPXSTREAM - - - IO_REPARSE_TAG_CSV - - - IO_REPARSE_TAG_DRIVER_EXTENDER - Used by Home server drive extender. - - - - IO_REPARSE_TAG_DEDUP - - - IO_REPARSE_TAG_DFS - Used by the DFS filter. - - - - IO_REPARSE_TAG_DFSR - Used by the DFS filter. - - - - IO_REPARSE_TAG_FILTER_MANAGER - Used by filter manager test harness. - - - - IO_REPARSE_TAG_HSM - (Obsolete) Used by legacy Hierarchical Storage Manager Product. - - - - IO_REPARSE_TAG_HSM2 - (Obsolete) Used by legacy Hierarchical Storage Manager Product. - - - - IO_REPARSE_TAG_NFS - NFS symlinks, Windows 8 / SMB3 and later. - - - - IO_REPARSE_TAG_MOUNT_POINT - Used for mount point support. - - - - IO_REPARSE_TAG_SIS - Used by single-instance storage (SIS) filter driver. - - - - IO_REPARSE_TAG_SYMLINK - Used for symbolic link support. - - - - IO_REPARSE_TAG_WIM - - - WIN32_STREAM_ID Attributes of data to facilitate cross-operating system transfer. - - - STREAM_NORMAL_ATTRIBUTE - This backup stream has no special attributes. - - - - STREAM_MODIFIED_WHEN_READ - Attribute set if the stream contains data that is modified when read. - Allows the backup application to know that verification of data will fail. - - - - STREAM_CONTAINS_SECURITY - The backup stream contains security information. - This attribute applies only to backup stream of type . - - - - Reserved. - - - STREAM_SPARSE_ATTRIBUTE - The backup stream is part of a sparse file stream. - This attribute applies only to backup stream of type , , and . - - - - The type of the data contained in the backup stream. - - - This indicates an error. - - - BACKUP_DATA - Standard data. This corresponds to the NTFS $DATA stream type on the default (unnamed) data stream. - - - - BACKUP_EA_DATA - Extended attribute data. This corresponds to the NTFS $EA stream type. - - - - BACKUP_SECURITY_DATA - Security descriptor data. - - - - BACKUP_ALTERNATE_DATA - Alternative data streams. This corresponds to the NTFS $DATA stream type on a named data stream. - - - - BACKUP_LINK - Hard link information. This corresponds to the NTFS $FILE_NAME stream type. - - - - BACKUP_PROPERTY_DATA - Property data. - - - - BACKUP_OBJECT_ID - Objects identifiers. This corresponds to the NTFS $OBJECT_ID stream type. - - - - BACKUP_REPARSE_DATA - Reparse points. This corresponds to the NTFS $REPARSE_POINT stream type. - - - - BACKUP_SPARSE_BLOCK - Sparse file. This corresponds to the NTFS $DATA stream type for a sparse file. - - - - BACKUP_TXFS_DATA - Transactional NTFS (TxF) data stream. - - Windows Server 2003 and Windows XP: This value is not supported. - - - Flags that specify how a file or directory is to be copied. - - - No CopyOptions used, this allows overwriting the file. - - - COPY_FILE_FAIL_IF_EXISTS - The copy operation fails immediately if the target file already exists. - - - - COPY_FILE_RESTARTABLE - - Progress of the copy is tracked in the target file in case the copy fails. The failed copy can be restarted at a later time by specifying the same values - forexisting file name and new file name as those used in the call that failed. This can significantly slow down the copy operation as the new file may be - flushed multiple times during the copy operation. - - - - - COPY_FILE_OPEN_SOURCE_FOR_WRITE - The file is copied and the original file is opened for write access. - - - - COPY_FILE_ALLOW_DECRYPTED_DESTINATION - An attempt to copy an encrypted file will succeed even if the destination copy cannot be encrypted. - - - - COPY_FILE_COPY_SYMLINK - If the source file is a symbolic link, the destination file is also a symbolic link pointing to the same file that the source symbolic link is pointing to. - - - - COPY_FILE_NO_BUFFERING - The copy operation is performed using unbuffered I/O, bypassing system I/O cache resources. Recommended for very large file transfers. - - - - Used by CopyFileXxx and MoveFileXxx. The reason that was called. - - - CALLBACK_CHUNK_FINISHED - Another part of the data file was copied. - - - - CALLBACK_STREAM_SWITCH - Another stream was created and is about to be copied. This is the callback reason given when the callback routine is first invoked. - - - - Provides static methods to retrieve device resource information from a local or remote host. - - - Enumerates all available devices on the local host. - instances of type from the local host. - One of the devices. - - - Enumerates all available devices of type on the local or remote host. - instances of type for the specified . - The name of the local or remote host on which the device resides. refers to the local host. - One of the devices. - - - Enumerates all available devices on the local or remote host. - - - Get information about the target of a mount point or symbolic link on an NTFS file system. - - - Sets the NTFS compression state of a file or directory on a volume whose file system supports per-file and per-directory compression. - Specifies that is a file or directory. - The transaction. - A path that describes a folder or file to compress or decompress. - = compress, = decompress - Indicates the format of the path parameter(s). - - - Builds a DeviceInfo Data structure. - An initialized NativeMethods.SP_DEVINFO_DATA instance. - - - Builds a Device Interface Data structure. - An initialized NativeMethods.SP_DEVICE_INTERFACE_DATA instance. - - - Builds a Device Interface Detail Data structure. - An initialized NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA instance. - - - Repeatedly invokes InvokeIoControl with the specified input until enough memory has been allocated. - - - The provides access to data associated with a specific file or directory, including security information and alternative data streams, for backup and restore operations. - This class uses the BackupRead, - BackupSeek and - BackupWrite functions from the Win32 API to provide access to the file or directory. - - - - Initializes a new instance of the class with the specified path and creation mode. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - The file will be opened for exclusive access for both reading and writing. - - - Initializes a new instance of the class with the specified path, creation mode and access rights. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - The file will be opened for exclusive access. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, and additional file attributes. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, additional file attributes, access control and audit security. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - A constant that determines the access control and audit security for the file. This parameter This parameter may be . - - - Initializes a new instance of the class with the specified path and creation mode. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - The file will be opened for exclusive access for both reading and writing. - - - Initializes a new instance of the class with the specified path, creation mode and access rights. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - The file will be opened for exclusive access. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, and additional file attributes. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - - - Initializes a new instance of the class with the specified path, creation mode, access rights and sharing permission, additional file attributes, access control and audit security. - The transaction. - A relative or absolute path for the file that the current object will encapsulate. - A constant that determines how to open or create the file. - A constant that determines the access rights to use when creating access and audit rules for the file. - A constant that determines how the file will be shared by processes. - A constant that specifies additional file attributes. - A constant that determines the access control and audit security for the file. This parameter This parameter may be . - - - Initializes a new instance of the class for the specified file handle, with the specified read/write permission. - A file handle for the file that this object will encapsulate. - A constant that gets the and properties of the object. - - - When overridden in a derived class, gets the length in bytes of the stream. - This method always throws an exception. - - - - When overridden in a derived class, gets or sets the position within the current stream. - This method always throws an exception. - - - - When overridden in a derived class, sets the position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - The new position within the current stream. - This stream does not support seeking using this method, and calling this method will always throw . See for an alternative way of seeking forward. - - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - This method is not supported by the class, and calling it will always generate a . - - - - Gets a value indicating whether the current stream supports reading. - if the stream supports reading, otherwise. - - - Gets a value indicating whether the current stream supports seeking. - This method always returns . - - - Gets a value indicating whether the current stream supports writing. - if the stream supports writing, otherwise. - - - Gets a object that represents the operating system file handle for the file that the current object encapsulates. - A object that represents the operating system file handle for the file that - the current object encapsulates. - - - Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - This method will not backup the access-control list (ACL) data for the file or directory. - - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between - and ( + - 1) replaced by the bytes read from the - current source. - - - The zero-based byte offset in at which to begin storing the data read from the current stream. - - The maximum number of bytes to be read from the current stream. - - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not - currently available, or zero (0) if the end of the stream has been reached. - - - - - - - - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values - between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - Indicates whether the function will backup the access-control list (ACL) data for the file or directory. - - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not - currently available, or zero (0) if the end of the stream has been reached. - - - - - - - - - Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - - Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - - - - - - This method will not process the access-control list (ACL) data for the file or directory. - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - Specifies whether the function will restore the access-control list (ACL) data for the file or directory. - If this is you need to specify and access when - opening the file or directory handle. If the handle does not have those access rights, the operating system denies - access to the ACL data, and ACL data restoration will not occur. - - - - - - - - Clears all buffers for this stream and causes any buffered data to be written to the underlying device. - - - Skips ahead the specified number of bytes from the current stream. - This method represents the Win32 API implementation of BackupSeek. - - Applications use the method to skip portions of a data stream that cause errors. This function does not - seek across stream headers. For example, this function cannot be used to skip the stream name. If an application - attempts to seek past the end of a substream, the function fails, the return value indicates the actual number of bytes - the function seeks, and the file position is placed at the start of the next stream header. - - - The number of bytes to skip. - The number of bytes actually skipped. - - - Gets a object that encapsulates the access control list (ACL) entries for the file described by the current object. - - - A object that encapsulates the access control list (ACL) entries for the file described by the current - object. - - - - Applies access control list (ACL) entries described by a object to the file described by the current object. - A object that describes an ACL entry to apply to the current file. - - - Prevents other processes from changing the while permitting read access. - The beginning of the range to lock. The value of this parameter must be equal to or greater than zero (0). - The range to be locked. - - - - - Allows access by other processes to all or part of a file that was previously locked. - The beginning of the range to unlock. - The range to be unlocked. - - - - - - Reads a stream header from the current . - The stream header read from the current , or if the end-of-file - was reached before the required number of bytes of a header could be read. - - The stream must be positioned at where an actual header starts for the returned object to represent valid - information. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - to release both managed and unmanaged resources; to release only unmanaged resources. - - - Releases unmanaged resources and performs other cleanup operations before the is reclaimed by garbage collection. - - - Represents the encryption status of the specified file. - - - The file can be encrypted. - - - The file is encrypted. - - - The file is a system file. System files cannot be encrypted. - - - The file is a root directory. Root directories cannot be encrypted. - - - The file is a system directory. System directories cannot be encrypted. - - - The encryption status is unknown. The file may be encrypted. - - - The file system does not support file encryption. - - - Reserved for future use. - - - The file is a read-only file. - - - Contains information that the GetFileInformationByHandle function retrieves. - - - Gets the file attributes. - The file attributes. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - Gets the time this entry was last accessed. - For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - If the underlying file system does not support the last access time, this member is zero (0). - - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - For a file, the structure specifies the last time that a file is read from or written to. - For a directory, the structure specifies when the directory is created. - For both files and directories, the specified date is correct, but the time of day is always set to midnight. - If the underlying file system does not support the last access time, this member is zero (0). - - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - If the underlying file system does not support the last access time, this member is zero (0). - - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - For a file, the structure specifies the last time that a file is written to. - For a directory, the structure specifies when the directory is created. - If the underlying file system does not support the last access time, this member is zero (0). - - The time, in coordinated universal time (UTC), this entry was last modified. - - - Gets the serial number of the volume that contains a file. - The serial number of the volume that contains a file. - - - Gets the size of the file. - The size of the file. - - - Gets the number of links to this file. For the FAT file system this member is always 1. For the NTFS file system, it can be more than 1. - The number of links to this file. - - - - Gets the unique identifier associated with the file. The identifier and the volume serial number uniquely identify a - file on a single computer. To determine whether two open handles represent the same file, combine the identifier - and the volume serial number for each file and compare them. - - The unique identifier of the file. - - - Contains information about files in the specified directory. Used for directory handles. - - - The number of bytes that are allocated for the file. This value is usually a multiple of the sector or cluster size of the underlying physical device. - - - Gets the time this entry was changed. - The time this entry was changed. - - - Gets the time, in coordinated universal time (UTC), this entry was changed. - The time, in coordinated universal time (UTC), this entry was changed. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - The size of the extended attributes for the file. - - - The absolute new end-of-file position as a byte offset from the start of the file to the end of the file. - Because this value is zero-based, it actually refers to the first free byte in the file. In other words, EndOfFile is the offset to - the byte that immediately follows the last valid byte in the file. - - - - The file attributes. - - - The file ID. - - - The byte offset of the file within the parent directory. This member is undefined for file systems, such as NTFS, - in which the position of a file within the parent directory is not fixed and can be changed at any time to maintain sort order. - - - - The name of the file. - - - Gets the time this entry was last accessed. - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - The time, in coordinated universal time (UTC), this entry was last modified. - - - The short 8.3 file naming convention (for example, FILENAME.TXT) name of the file. - - - Provides properties and instance methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of objects. This class cannot be inherited. - - - [AlphaFS] Calculates the hash/checksum. - One of the values. - - - Refreshes the state of the EntryInfo instance. - - - [AlphaFS] Returns an enumerable collection of instances for the file. - An enumerable collection of instances for the file. - - - [AlphaFS] Decompresses an NTFS compressed file. - - - [AlphaFS] Compresses a file using NTFS compression. - - - Returns the path as a string. - The path. - - - Applies access control list (ACL) entries described by a FileSecurity object to the file described by the current FileInfo object. - - The SetAccessControl method applies access control list (ACL) entries to the current file that represents the noninherited ACL - list. Use the SetAccessControl method whenever you need to add or remove ACL entries from a file. - - A object that describes an access control list (ACL) entry to apply to the current file. - - - Applies access control list (ACL) entries described by a FileSecurity object to the file described by the current FileInfo object. - - The SetAccessControl method applies access control list (ACL) entries to the current file that represents the noninherited ACL - list. Use the SetAccessControl method whenever you need to add or remove ACL entries from a file. - - A object that describes an access control list (ACL) entry to apply to the current file. - One or more of the values that specifies the type of access control list (ACL) information to set. - - - Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - - - Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise, . - - - [AlphaFS] Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - Indicates the format of the path parameter(s). - - - [AlphaFS] Replaces the contents of a specified file with the file described by the current object, deleting the original file, and creating a backup of the replaced file. Also specifies whether to ignore merge errors. - A object that encapsulates information about the file described by the parameter. - - The Replace method replaces the contents of a specified file with the contents of the file described by the current - object. It also creates a backup of the file that was replaced. Finally, it returns a new - object that describes the overwritten file. - - Pass null to the parameter if you do not want to create a backup of the file being replaced. - The name of a file to replace with the current file. - The name of a file with which to create a backup of the file described by the parameter. - to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise, . - Indicates the format of the path parameter(s). - - - Refreshes the state of the object. - - - Creates a write-only . - A write-only unshared object for a new or existing file. - - - Creates a with NativeMethods.DefaultFileEncoding encoding that reads from an existing text file. - A new with NativeMethods.DefaultFileEncoding encoding. - - - [AlphaFS] Creates a with that reads from an existing text file. - A new with the specified . - The applied to the contents of the file. - - - Creates a read-only . - A new read-only object. - This method returns a read-only object with the mode set to Read. - - - Opens a file in the specified mode. - A file opened in the specified mode, with read/write access and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - - - Opens a file in the specified mode with read, write, or read/write access. - A object opened in the specified mode and access, and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A constant specifying whether to open the file with Read, Write, or ReadWrite file access. - - - Opens a file in the specified mode with read, write, or read/write access and the specified sharing option. - A object opened with the specified mode, access, and sharing options. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A constant specifying whether to open the file with Read, Write, or ReadWrite file access. - A constant specifying the type of access other objects have to this file. - - - [AlphaFS] Opens a file in the specified mode with read, write, or read/write access. - A object opened in the specified mode and access, and unshared. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - - - [AlphaFS] Opens a file in the specified mode with read, write, or read/write access and the specified sharing option. - A object opened with the specified mode, access, and sharing options. - A constant specifying the mode (for example, Open or Append) in which to open the file. - A value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten along with additional options. - A constant specifying the type of access other objects have to this file. - - - Gets a object that encapsulates the access control list (ACL) entries for the file described by the current object. - A FileSecurity object that encapsulates the access control rules for the current file. - - - Gets a object that encapsulates the specified type of access control list (ACL) entries for the file described by the current FileInfo object. - object that encapsulates the specified type of access control list (ACL) entries for the file described by the current FileInfo object. - One of the values that specifies which group of access control entries to retrieve. - - - Encrypts a file so that only the account used to encrypt the file can decrypt it. - - - Permanently deletes a file. - If the file does not exist, this method does nothing. - - - - - [AlphaFS] Permanently deletes a file. - If the file does not exist, this method does nothing. - overrides the read only of the file. - - - Decrypts a file that was encrypted by the current account using the Encrypt method. - - - Creates a instance that writes a new text file. - A new - - - Creates a file. - A new file. - - - Copies an existing file to a new file, disallowing the overwriting of an existing file. - A new instance with a fully qualified path. - - Use this method to prevent overwriting of an existing file by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - - - Copies an existing file to a new file, allowing the overwriting of an existing file. - - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - to allow an existing file to be overwritten; otherwise, . - - - [AlphaFS] Copies an existing file to a new file, disallowing the overwriting of an existing file. - - Use this method to prevent overwriting of an existing file by default. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file. - - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - to allow an existing file to be overwritten; otherwise, . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A new instance with a fully qualified path. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Copies an existing file to a new file, allowing the overwriting of an existing file, can be specified. - and the possibility of notifying the application of its progress through a callback function. - - Option is recommended for very large file transfers. - Use this method to allow or prevent overwriting of an existing file. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Copy action. - - - - - - - - The name of the new file to copy to. - that specify how the file is to be copied. - if original Timestamps must be preserved, otherwise. - A callback function that is called each time another portion of the file has been copied. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Moves a specified file to a new location, providing the option to specify a new file name. - - Use this method to prevent overwriting of an existing file by default. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with details of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to prevent overwriting of an existing file by default. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - Returns a new instance with a fully qualified path when successfully moved, - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable - behavior. - - - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - Indicates the format of the path parameter(s). - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified, - and the possibility of notifying the application of its progress through a callback function. - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - - - [AlphaFS] Moves a specified file to a new location, providing the option to specify a new file name, can be specified. - - Use this method to allow or prevent overwriting of an existing file. - This method works across disk volumes. - For example, the file c:\MyFile.txt can be moved to d:\public and renamed NewFile.txt. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Move action. - - - - - - - - The path to move the file to, which can specify a different file name. - that specify how the directory is to be moved. This parameter can be . - A callback function that is called each time another portion of the directory has been moved. This parameter can be . - The argument to be passed to the callback function. This parameter can be . - Indicates the format of the path parameter(s). - - - Copy/move an existing file to a new file, allowing the overwriting of an existing file. - - Option is recommended for very large file transfers. - Whenever possible, avoid using short file names (such as XXXXXX~1.XXX) with this method. - If two files have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior. - - - A class with the status of the Copy or Move action. - A full path string to the destination directory - if original Timestamps must be preserved, otherwise. - This parameter can be . Use to specify how the file is to be copied. - This parameter can be . Use that specify how the file is to be moved. - This parameter can be . A callback function that is called each time another portion of the file has been copied. - This parameter can be . The argument to be passed to the callback function. - [out] Returns the retrieved long full path. - Indicates the format of the path parameter(s). - - - - - - - - - Creates a that appends text to the file represented by this instance of the . - A new - - - Creates a that appends text to the file represented by this instance of the . - The character to use. - A new - - - Initializes a new instance of the class, which acts as a wrapper for a file path. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The transaction. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - [AlphaFS] Initializes a new instance of the class, which acts as a wrapper for a file path. - The transaction. - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - - Gets an instance of the parent directory. - A object representing the parent directory of this file. - To get the parent directory as a string, use the DirectoryName property. - - - - Gets a string representing the directory's full path. - A string representing the directory's full path. - - To get the parent directory as a DirectoryInfo object, use the Directory property. - When first called, FileInfo calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - - - - - Gets a value indicating whether the file exists. - if the file exists; otherwise, . - - The property returns if any error occurs while trying to determine if the specified file exists. - This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters, - a failing or missing disk, or if the caller does not have permission to read the file. - - - - Gets or sets a value that determines if the current file is read only. - if the current file is read only; otherwise, . - - Use the IsReadOnly property to quickly determine or change whether the current file is read only. - When first called, FileInfo calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - - - - - - Gets the size, in bytes, of the current file. - The size of the current file in bytes. - - The value of the Length property is pre-cached - To get the latest value, call the Refresh method. - - - - - - Gets the name of the file. - The name of the file. - - The name of the file includes the file extension. - When first called, calls Refresh and caches information about the file. - On subsequent calls, you must call Refresh to get the latest copy of the information. - The name of the file includes the file extension. - - - - Specifies how the operating system should open a file. - - - If you pass , the set of attributes is unspecified. explicitly sets no attributes. - - - The file is read only. Applications can read the file, but cannot write to or delete it. - Equals 1 - - - The file is hidden. Do not include it in an ordinary directory listing. - Equals 2 - - - The file is part of or used exclusively by an operating system. - Equals 4 - - - The handle that identifies a directory. - Equals 16 - - - The file should be archived. Applications use this attribute to mark files for backup or removal. - Equals 32 - - - The file should be archived. Applications use this attribute to mark files for backup or removal. - Equals 64 - - - The file does not have other attributes set. This attribute is valid only if used alone. - Equals 128 - - - The file is being used for temporary storage. - Equals 256 - - - A file that is a sparse file. - Equals 512 - - - A file or directory that has an associated reparse point, or a file that is a symbolic link. - Equals 1024 - - - A file or directory that is compressed. For a file, all of the data in the file is compressed. For a directory, compression is the default for newly created files and subdirectories. - Equals 2048 - - - The data of a file is not immediately available. This attribute indicates that file data is physically moved to offline storage. This attribute is used by Remote Storage, the hierarchical storage management software. Applications should not arbitrarily change this attribute. - Equals 4096 - - - The file or directory is not to be indexed by the content indexing service. - Equals 8192 - - - The file or directory is encrypted. For a file, this means that all data in the file is encrypted. For a directory, this means that encryption is the default for newly created files and subdirectories. - Equals 16384 - - - The directory or user data stream is configured with integrity (only supported on ReFS volumes). It is not included in an ordinary directory listing. The integrity setting persists with the file if it's renamed. If a file is copied the destination file will have integrity set if either the source file or destination directory have integrity set. - This flag is not supported until Windows Server 2012. - - - The user data stream not to be read by the background data integrity scanner (AKA scrubber). When set on a directory it only provides inheritance. This flag is only supported on Storage Spaces and ReFS volumes. It is not included in an ordinary directory listing. - This flag is not supported until Windows Server 2012. - - - ... - - - The file data is requested, but it should continue to be located in remote storage. It should not be transported back to local storage. This flag is for use by remote storage systems. - - - Normal reparse point processing will not occur; an attempt to open the reparse point will be made. When a file is opened, a file handle is returned, whether or not the filter that controls the reparse point is operational. See MSDN documentation for more information. - - - Access will occur according to POSIX rules. This includes allowing multiple files with names, differing only in case, for file systems that support that naming. Use care when using this option, because files created with this flag may not be accessible by applications that are written for MS-DOS or 16-bit Windows. - - - The file is being opened or created for a backup or restore operation. The system ensures that the calling process overrides file security checks when the process has SE_BACKUP_NAME and SE_RESTORE_NAME privileges. You must set this flag to obtain a handle to a directory. A directory handle can be passed to some functions instead of a file handle. - - - The file is to be deleted immediately after all of its handles are closed, which includes the specified handle and any other open or duplicated handles. If there are existing open handles to a file, the call fails unless they were all opened with the share mode. Subsequent open requests for the file fail, unless the share mode is specified. - Equals 67108864 - - - Access is intended to be sequential from beginning to end. The system can use this as a hint to optimize file caching. - Equals 134217728 - - - Access is intended to be random. The system can use this as a hint to optimize file caching. - Equals 268435456 - - - There are strict requirements for successfully working with files opened with the flag, for details see the section on "File Buffering" in the online MSDN documentation. - - - The file or device is being opened or created for asynchronous I/O. - Equals 1073741824 - - - Write operations will not go through any intermediate cache, they will go directly to disk. - Equals .NET -2147483648 - - - Class that retrieves file system entries (i.e. files and directories) using Win32 API FindFirst()/FindNext(). - - - Get an enumerator that returns all of the file system objects that match the wildcards that are in any of the directories to be searched. - An instance: FileSystemEntryInfo, DirectoryInfo, FileInfo or string (full path). - - - Gets a specific file system object. - - The return type is based on C# inference. Possible return types are: - - (full path), - ( or ), instance - or null in case an Exception is raised and is . - - - - Gets or sets the ability to return the object as a instance. - returns the object as a instance. - - - Gets or sets the ability to return the full path in long full path format. - returns the full path in long full path format, returns the full path in regular path format. - - - Gets or sets the ability to return the object instance as a . - returns the full path of the object as a - - - Gets the value indicating which to use. - - - Gets or sets the ability to skip on access errors. - suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points. - - - Gets the file system object type. - - = Return files and directories. - = Return only directories. - = Return only files. - - - - Gets or sets if the path is an absolute or relative path. - Gets a value indicating whether the specified path string contains absolute or relative path information. - - - Gets or sets the initial path to the folder. - The initial path to the file or folder in long path format. - - - Gets or sets the path to the folder. - The path to the file or folder in long path format. - - - Gets or sets a value indicating which to use. - indicates a folder object, indicates a file object. - - - Gets the value indicating which to use. - - - Specifies whether the search should include only the current directory or should include all subdirectories. - to all subdirectories. - - - Search for file system object-name using a pattern. - The path which has wildcard characters, for example, an asterisk () or a question mark (). - - - skips ReparsePoints, will follow ReparsePoints. - - - Get or sets the KernelTransaction instance. - The transaction. - - - Represents information about a file system entry. - This class cannot be inherited. - - - - Initializes a new instance of the class. - The NativeMethods.WIN32_FIND_DATA structure. - - - Gets the 8.3 version of the filename. - the 8.3 version of the filename. - - - Gets the attributes. - The attributes. - - - Gets the time this entry was created. - The time this entry was created. - - - Gets the time, in coordinated universal time (UTC), this entry was created. - The time, in coordinated universal time (UTC), this entry was created. - - - Gets the name of the file. - The name of the file. - - - Gets the size of the file. - The size of the file. - - - The full path of the file system object. - - - Gets a value indicating whether this instance is compressed. - if this instance is compressed; otherwise, . - - It is not possible to change the compression status of a File object by using the SetAttributes method. - Instead, you must actually compress the file using either a compression tool or one of the classes in the namespace. - - - - Gets a value indicating whether this instance is hidden, and thus is not included in an ordinary directory listing. - if this instance is hidden; otherwise, . - - - Gets a value indicating whether this instance represents a directory. - if this instance represents a directory; otherwise, . - - - Gets a value indicating whether this instance is encrypted (EFS). - if this instance is encrypted (EFS); otherwise, . - - For a file, this means that all data in the file is encrypted. - For a directory, this means that encryption is the default for newly created files and directories. - - - - Gets a value indicating whether this instance is a mount point. - if this instance is a mount point; otherwise, . - - - Gets a value indicating whether this instance is offline. The data of the file is not immediately available. - if this instance is offline; otherwise, . - - - Gets a value indicating whether this instance is read-only. - if this instance is read-only; otherwise, . - - - Gets a value indicating whether this instance contains a reparse point, which is a block of user-defined data associated with a file or a directory. - if this instance contains a reparse point; otherwise, . - - - Gets a value indicating whether this instance is a symbolic link. - if this instance is a symbolic link; otherwise, . - - - Gets the time this entry was last accessed. - The time this entry was last accessed. - - - Gets the time, in coordinated universal time (UTC), this entry was last accessed. - The time, in coordinated universal time (UTC), this entry was last accessed. - - - Gets the time this entry was last modified. - The time this entry was last modified. - - - Gets the time, in coordinated universal time (UTC), this entry was last modified. - The time, in coordinated universal time (UTC), this entry was last modified. - - - The full path of the file system object in Unicode (LongPath) format. - - - Gets the reparse point tag of this entry. - The reparse point tag of this entry. - - - Gets internal WIN32 FIND Data - - - Returns the of the instance. - The instance as a string. - - - Provides the base class for both and objects. - - - Deletes a file or directory. - - - Refreshes the state of the object. - - FileSystemInfo.Refresh() takes a snapshot of the file from the current file system. - Refresh cannot correct the underlying file system even if the file system returns incorrect or outdated information. - This can happen on platforms such as Windows 98. - Calls must be made to Refresh() before attempting to get the attribute information, or the information will be - outdated. - - - - Returns a string that represents the current object. - - ToString is the major formatting method in the .NET Framework. It converts an object to its string representation so that it is - suitable for display. - - A string that represents this instance. - - - Determines whether the specified Object is equal to the current Object. - Another object to compare to. - if the specified Object is equal to the current Object; otherwise, . - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Implements the operator == - A. - B. - The result of the operator. - - - Implements the operator != - A. - B. - The result of the operator. - - - Refreshes the state of the EntryInfo instance. - - FileSystemInfo.RefreshEntryInfo() takes a snapshot of the file from the current file system. - Refresh cannot correct the underlying file system even if the file system returns incorrect or outdated information. - This can happen on platforms such as Windows 98. - Calls must be made to Refresh() before attempting to get the attribute information, or the information will be outdated. - - - - [AlphaFS] Resets the state of the file system object to uninitialized. - - - Initializes the specified file name. - - - Specifies that is a file or directory. - The transaction. - The full path and name of the file. - Indicates the format of the path parameter(s). - - - - Gets or sets the attributes for the current file or directory. - - - The value of the CreationTime property is pre-cached - To get the latest value, call the Refresh method. - - of the current . - - - - - - - Gets or sets the creation time of the current file or directory. - - The value of the CreationTime property is pre-cached To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions whose values may not be continuously updated by - the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - NTFS-formatted drives may cache file meta-info, such as file creation time, for a short period of time. - This process is known as file tunneling. As a result, it may be necessary to explicitly set the creation time of a file if you are - overwriting or replacing an existing file. - - The creation date and time of the current object. - - - - - - Gets or sets the creation time, in coordinated universal time (UTC), of the current file or directory. - - The value of the CreationTimeUtc property is pre-cached - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - To get the latest value, call the Refresh method. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC). - NTFS-formatted drives may cache file meta-info, such as file creation time, for a short period of time. - This process is known as file tunneling. As a result, it may be necessary to explicitly set the creation time - of a file if you are overwriting or replacing an existing file. - - The creation date and time in UTC format of the current object. - - - - - - - Gets a value indicating whether the file or directory exists. - - - The property returns if any error occurs while trying to determine if the - specified file or directory exists. - This can occur in situations that raise exceptions such as passing a directory- or file name with invalid characters or too - many characters, - a failing or missing disk, or if the caller does not have permission to read the file or directory. - - if the file or directory exists; otherwise, . - - - - Gets the string representing the extension part of the file. - - - The Extension property returns the extension, including the period (.). - For example, for a file c:\NewFile.txt, this property returns ".txt". - - A string containing the extension. - - - - Gets the full path of the directory or file. - - A string containing the full path. - - - Gets or sets the time the current file or directory was last accessed. - - The value of the LastAccessTime property is pre-cached - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The time that the current file or directory was last accessed. - - - - - Gets or sets the time, in coordinated universal time (UTC), that the current file or directory was last accessed. - - The value of the LastAccessTimeUtc property is pre-cached. - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The UTC time that the current file or directory was last accessed. - - - - - Gets or sets the time when the current file or directory was last written to. - - The value of the LastWriteTime property is pre-cached. - To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions - whose values may not be continuously updated by the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return - 12:00 midnight, January 1, 1601 A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The time the current file was last written. - - - - - Gets or sets the time, in coordinated universal time (UTC), when the current file or directory was last written to. - - The value of the LastWriteTimeUtc property is pre-cached. To get the latest value, call the Refresh method. - This method may return an inaccurate value, because it uses native functions whose values may not be continuously updated by - the operating system. - If the file described in the FileSystemInfo object does not exist, this property will return 12:00 midnight, January 1, 1601 - A.D. (C.E.) Coordinated Universal Time (UTC), adjusted to local time. - - The UTC time when the current file was last written to. - - - - For files, gets the name of the file. For directories, gets the name of the last directory in the hierarchy if a hierarchy exists. - Otherwise, the Name property gets the name of the directory. - - - For a directory, Name returns only the name of the parent directory, such as Dir, not c:\Dir. - For a subdirectory, Name returns only the name of the subdirectory, such as Sub1, not c:\Dir\Sub1. - For a file, Name returns only the file name and file name extension, such as MyFile.txt, not c:\Dir\Myfile.txt. - - - A string that is the name of the parent directory, the name of the last directory in the hierarchy, - or the name of a file, including the file name extension. - - - - Returns the path as a string. - - - [AlphaFS] Gets the instance of the class. - - - [AlphaFS] The initial "IsDirectory" indicator that was passed to the constructor. - - - The full path of the file system object in Unicode (LongPath) format. - - - [AlphaFS] Represents the KernelTransaction that was passed to the constructor. - - - Represents the fully qualified path of the file or directory. - - Classes derived from can use the FullPath field - to determine the full path of the object being manipulated. - - - - The path originally specified by the user, whether relative or absolute. - - - A bitfield of flags for specifying options for various internal operations that convert paths to full paths. - - - No special options applies. - - - Remove any trailing whitespace from the path. - - - Add a trailing directory separator to the path (if one does not already exist). - - - Remove the trailing directory separator from the path (if one exists). - - - Return full path as long full path (Unicode format). Not valid for . - - - Prevents any exception from being thrown if a filesystem object does not exist. Not valid for . - - - Check that the path contains only valid path-characters. - - - Also check for wildcard (? and *) characters. - - - Do not trim the trailing dot or space. - - - Performs both and checks. - - - Performs operations on String instances that contain file or directory path information. These operations are performed in a cross-platform manner. - - - Determines whether a path includes a file name extension. - if the characters that follow the last directory separator (\\ or /) or volume separator (:) in the path include a period (.) followed by one or more characters; otherwise, . - - The path to search for an extension. The path cannot contain any of the characters defined in . - - - Gets a value indicating whether the specified path string contains absolute or relative path information. - if contains a root; otherwise, . - - The IsPathRooted method returns if the first character is a directory separator character such as - , or if the path starts with a drive letter and colon (). - For example, it returns true for path strings such as "\\MyDir\\MyFile.txt", "C:\\MyDir", or "C:MyDir". - It returns for path strings such as "MyDir". - - This method does not verify that the path or file name exists. - - - The path to test. The path cannot contain any of the characters defined in . - - - [AlphaFS] Gets a value indicating whether the specified path string contains absolute or relative path information. - if contains a root; otherwise, . - - The IsPathRooted method returns true if the first character is a directory separator character such as - , or if the path starts with a drive letter and colon (). - For example, it returns for path strings such as "\\MyDir\\MyFile.txt", "C:\\MyDir", or "C:MyDir". - It returns for path strings such as "MyDir". - - This method does not verify that the path or file name exists. - - - The path to test. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - [AlphaFS] Check if file or folder name has any invalid characters. - - File or folder name. - if name contains any invalid characters. Otherwise - - - Checks that the given path format is supported. - - - A path to the file or directory. - Checks that the path contains only valid path-characters. - . - - - Checks that the path contains only valid path-characters. - - - A path to the file or directory. - also checks for ? and * characters. - When , throws an . - - - Tranlates DosDevicePath, Volume GUID. For example: "\Device\HarddiskVolumeX\path\filename.ext" can translate to: "\path\filename.ext" or: "\\?\Volume{GUID}\path\filename.ext". - A translated dos path. - A DosDevicePath, for example: \Device\HarddiskVolumeX\path\filename.ext. - Alternate path/device text, usually string.Empty or . - - - Check if is a directory- and/or volume-separator character. - if is a separator character. - The character to check. - - If , checks for all separator characters: , - and - If , only checks for: and - If only checks for: - - - - Changes the extension of a path string. - The modified path information. - - The path information to modify. The path cannot contain any of the characters defined in . - The new extension (with or without a leading period). Specify to remove an existing extension from path. - - - Returns the directory information for the specified path string. - - Directory information for , or if denotes a root directory or is - . - Returns if does not contain directory information. - - - The path of a file or directory. - - - [AlphaFS] Returns the directory information for the specified path string. - - Directory information for , or if denotes a root directory or is - . Returns if does not contain directory information. - - - The path of a file or directory. - will check for invalid path characters. - - - [AlphaFS] Returns the directory information for the specified path string without the root information, for example: "C:\Windows\system32" returns: "Windows". - The without the file name part and without the root information (if any), or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - The path. - - - [AlphaFS] Returns the directory information for the specified path string without the root information, for example: "C:\Windows\system32" returns: "Windows". - The without the file name part and without the root information (if any), or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - The transaction. - The path. - - - Returns the extension of the specified path string. - - The extension of the specified path (including the period "."), or null, or . - If is null, this method returns null. - If does not have extension information, - this method returns . - - - - The path string from which to get the extension. The path cannot contain any of the characters defined in . - - - Returns the extension of the specified path string. - - The extension of the specified path (including the period "."), or null, or . - If is null, this method returns null. - If does not have extension information, - this method returns . - - - The path string from which to get the extension. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - Returns the file name and extension of the specified path string. - - The characters after the last directory character in . If the last character of is a - directory or volume separator character, this method returns string.Empty. If path is null, this method returns null. - - - The path string from which to obtain the file name and extension. The path cannot contain any of the characters defined in . - - - [AlphaFS] Returns the file name and extension of the specified path string. - - The characters after the last directory character in . If the last character of is a - directory or volume separator character, this method returns string.Empty. If path is null, this method returns null. - - - The path string from which to obtain the file name and extension. - will check for invalid path characters. - - - Returns the file name of the specified path string without the extension. - The string returned by GetFileName, minus the last period (.) and all characters following it. - - The path of the file. The path cannot contain any of the characters defined in . - - - [AlphaFS] Returns the file name of the specified path string without the extension. - The string returned by GetFileName, minus the last period (.) and all characters following it. - - The path of the file. The path cannot contain any of the characters defined in . - will check for invalid path characters. - - - Gets an array containing the characters that are not allowed in file names. - An array containing the characters that are not allowed in file names. - - - Gets an array containing the characters that are not allowed in path names. - An array containing the characters that are not allowed in path names. - - - Gets the root directory information of the specified path. - - Returns the root directory of , such as "C:\", - or if is , - or an empty string if does not contain root directory information. - - - The path from which to obtain root directory information. - - - [AlphaFS] Gets the root directory information of the specified path. - - Returns the root directory of , such as "C:\", - or if is , - or an empty string if does not contain root directory information. - - - The path from which to obtain root directory information. - will check for invalid path characters. - - - [AlphaFS] Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". - - Then handle to a instance. - - - [AlphaFS] Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". - - Then handle to a instance. - The final path, formatted as - - - Retrieves the final path for the specified file, formatted as . - The final path as a string. - - A final path is the path that is returned when a path is fully resolved. For example, for a symbolic link named "C:\tmp\mydir" that - points to "D:\yourdir", the final path would be "D:\yourdir". The string that is returned by this function uses the - syntax. - - Then handle to a instance. - The final path, formatted as - - - Combines an array of strings into a path. - The combined paths. - - - An array of parts of the path. - - - Combines an array of strings into a path. - The combined paths. - - The parameters are not parsed if they have white space. - Therefore, if path2 includes white space (for example, " c:\\ "), - the Combine method appends path2 to path1 instead of returning only path2. - - - - will not check for invalid path characters. - An array of parts of the path. - - - AltDirectorySeparatorChar = '/' Provides a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - DirectorySeparatorChar = '\' Provides a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - PathSeparator = ';' A platform-specific separator character used to separate path strings in environment variables. - - - VolumeSeparatorChar = ':' Provides a platform-specific Volume Separator character. - - - [AlphaFS] AltDirectorySeparatorChar = "/" Provides a platform-specific alternate string used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - [AlphaFS] CurrentDirectoryPrefix = '.' Provides a current directory character. - - - [AlphaFS] CurrentDirectoryPrefix = "." Provides a current directory string. - - - [AlphaFS] DirectorySeparator = "\" Provides a platform-specific string used to separate directory levels in a path string that reflects a hierarchical file system organization. - - - [AlphaFS] ExtensionSeparatorChar = '.' Provides an Extension Separator character. - - - [AlphaFS] ParentDirectoryPrefix = ".." Provides a parent directory string. - - - [AlphaFS] StreamSeparator = ':' Provides a platform-specific Stream-name character. - - - [AlphaFS] StreamSeparator = ':' Provides a platform-specific Stream-name character. - - - [AlphaFS] StreamDataLabel = ':$DATA' Provides a platform-specific Stream :$DATA label. - - - [AlphaFS] StringTerminatorChar = '\0' String Terminator Suffix. - - - [AlphaFS] Characters to trim from the SearchPattern. - - - [AlphaFS] VolumeSeparatorChar = ':' Provides a platform-specific Volume Separator character. - - - [AlphaFS] WildcardStarMatchAll = "*" Provides a match-all-items string. - - - [AlphaFS] WildcardStarMatchAll = '*' Provides a match-all-items character. - - - [AlphaFS] WildcardQuestion = "?" Provides a replace-item string. - - - [AlphaFS] WildcardQuestion = '?' Provides a replace-item string. - - - [AlphaFS] UncPrefix = "\\" Provides standard Windows Path UNC prefix. - - - [AlphaFS] LongPathPrefix = "\\?\" Provides standard Windows Long Path prefix. - - - [AlphaFS] LongPathUncPrefix = "\\?\UNC\" Provides standard Windows Long Path UNC prefix. - - - [AlphaFS] GlobalRootPrefix = "\\?\GLOBALROOT\" Provides standard Windows Volume prefix. - - - [AlphaFS] MsDosNamespacePrefix = "\\.\" Provides standard logical drive prefix. - - - [AlphaFS] SubstitutePrefix = "\??\" Provides a SUBST.EXE Path prefix to a Logical Drive. - - - [AlphaFS] VolumePrefix = "\\?\Volume" Provides standard Windows Volume prefix. - - - [AlphaFS] DevicePrefix = "\Device\" Provides standard Windows Device prefix. - - - [AlphaFS] DosDeviceLanmanPrefix = "\Device\LanmanRedirector\" Provides a MS-Dos Lanman Redirector Path UNC prefix to a network share. - - - [AlphaFS] DosDeviceMupPrefix = "\Device\Mup\" Provides a MS-Dos Mup Redirector Path UNC prefix to a network share. - - - [AlphaFS] DosDeviceUncPrefix = "\??\UNC\" Provides a SUBST.EXE Path UNC prefix to a network share. - - - Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The file or directory for which to obtain absolute path information. - - - Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - [AlphaFS] Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The transaction. - The file or directory for which to obtain absolute path information. - - - [AlphaFS] Returns the absolute path for the specified path string. - The fully qualified location of path, such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - - The transaction. - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - Retrieves the absolute path for the specified string. - The fully qualified location of , such as "C:\MyFile.txt". - - GetFullPathName merges the name of the current drive and directory with a specified file name to determine the full path and file name of a specified file. - It also calculates the address of the file name portion of the full path and file name. -   - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - The .NET Framework does not support direct access to physical disks through paths that are device names, such as "\\.\PHYSICALDRIVE0". -   - MSDN: Multithreaded applications and shared library code should not use the GetFullPathName function and - should avoid using relative path names. The current directory state written by the SetCurrentDirectory function is stored as a global variable in each process, - therefore multithreaded applications cannot reliably use this value without possible data corruption from other threads that may also be reading or setting this value. - This limitation also applies to the SetCurrentDirectory and GetCurrentDirectory functions. The exception being when the application is guaranteed to be running in a single thread, - for example parsing file names from the command line argument string in the main thread prior to creating any additional threads. - Using relative path names in multithreaded applications or shared library code can yield unpredictable results and is not supported. - - - - The transaction. - The file or directory for which to obtain absolute path information. - Options for controlling the full path retrieval. - - - Applies the to - with applied . - - - - - - - [AlphaFS] Adds a trailing character to the string, when absent. - A text string with a trailing character. The function returns when is . - A text string to which the trailing is to be added, when absent. - - - [AlphaFS] Adds a trailing or character to the string, when absent. - A text string with a trailing or character. The function returns when is . - A text string to which the trailing or is to be added, when absent. - If the character will be added instead. - - - [AlphaFS] Removes the trailing character from the string, when present. - A text string where the trailing character has been removed. The function returns when is . - A text string from which the trailing is to be removed, when present. - - - [AlphaFS] Removes the trailing or character from the string, when present. - A text string where the trailing or character has been removed. The function returns when is . - A text string from which the trailing or is to be removed, when present. - If the trailing character will be removed instead. - - - [AlphaFS] Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The path. - - - [AlphaFS] Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The transaction. - The path. - - - [AlphaFS] Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The path. - - - [AlphaFS] Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The transaction. - The path. - - - Returns the directory information for the specified with a trailing character. - - The suffixed directory information for the specified with a trailing character, - or if is or if denotes a root (such as "\", "C:", or * "\\server\share"). - - This method is similar to calling Path.GetDirectoryName() + Path.AddTrailingDirectorySeparator() - The transaction. - The path. - - - Returns the directory information for the specified without the root and with a trailing character. - - The directory information for the specified without the root and with a trailing character, - or if is or if is . - - The transaction. - The path. - - - [AlphaFS] Gets the connection name of the locally mapped drive. - The server and share as: \\servername\sharename. - - - - - The local path with drive name. - - - [AlphaFS] Gets the network share name from the locally mapped path. - The network share connection name of . - - - - - The local path with drive name. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path, optionally skip invalid path character check. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - will check for invalid path characters. - - - [AlphaFS] Converts a local path to a network share path. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - - - [AlphaFS] Converts a local path to a network share path, optionally returning it in a long path format. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - - - [AlphaFS] Converts a local path to a network share path, optionally returning it in a long path format and the ability to add or remove a trailing backslash. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - adds a trailing character to , when absent. - removes the trailing character from , when present. - - - [AlphaFS] Determines if a path string is a valid Universal Naming Convention (UNC) path, optionally skip invalid path character check. - if the specified path is a Universal Naming Convention (UNC) path, otherwise. - The path to check. - When indicates that is already in regular path format. - will check for invalid path characters. - - - Converts a local path to a network share path. - A Local path, e.g.: "C:\Windows" will be returned as: "\\MachineName\C$\Windows". - If a logical drive points to a network share path, the share path will be returned instead. - - On successful conversion a UNC path is returned. - If the conversion fails, is returned. - If is an empty string or , is returned. - - - - - A local path, e.g.: "C:\Windows". - returns the path in long path (Unicode) format, when returns the path as a regular path. - adds a trailing character to , when absent. - removes the trailing character from , when present. - - - Makes an extended long path from the specified by prefixing . - The prefixed with a , the minimum required full path is: "C:\". - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - - - The path to the file or directory, this can also be an UNC path. - - - [AlphaFS] Converts the specified existing path to its regular long form. - An existing path to a folder or file. - The regular full path. - - - [AlphaFS] Converts the specified existing path to its regular long form. - The transaction. - An existing path to a folder or file. - The regular full path. - - - [AlphaFS] Gets the regular path from long prefixed one. i.e.: "\\?\C:\Temp\file.txt" to C:\Temp\file.txt" or: "\\?\UNC\Server\share\file.txt" to "\\Server\share\file.txt". - Regular form path string. - This method does not handle paths with volume names, eg. \\?\Volume{GUID}\Folder\file.txt. - The path. - - - [AlphaFS] Retrieves the short path form of the specified path. - A path that has the 8.3 path form. - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short path name. - An existing path to a folder or file. - - - [AlphaFS] Retrieves the short path form of the specified path. - A path that has the 8.3 path form. - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short path name. - The transaction. - An existing path to a folder or file. - - - [AlphaFS] Determines whether the specified path starts with a or . - if the specified path has a long path (UNC) prefix, otherwise. - The path to the file or directory. - - - Makes an extended long path from the specified by prefixing . - The prefixed with a , the minimum required full path is: "C:\". - This method does not verify that the resulting path and file name are valid, or that they see an existing file on the associated volume. - - - The path to the file or directory, this can also be an UNC path. - Options for controlling the full path retrieval. - - - Retrieves the short path form, or the regular long form of the specified . - If is , a path of the 8.3 form otherwise the regular long form. - - Will fail on NTFS volumes with disabled 8.3 name generation. - The path must actually exist to be able to get the short- or long path name. - - The transaction. - An existing path to a folder or file. - to retrieve the short path form, to retrieve the regular long form from the 8.3 . - - - Gets the regular path from a long path. - - Returns the regular form of a long . - For example: "\\?\C:\Temp\file.txt" to: "C:\Temp\file.txt", or: "\\?\UNC\Server\share\file.txt" to: "\\Server\share\file.txt". - - - MSDN: String.TrimEnd Method notes to Callers: http://msdn.microsoft.com/en-us/library/system.string.trimend%28v=vs.110%29.aspx - - - - The path. - Options for controlling the full path retrieval. - When , throws an . - - - Gets the path as a long full path. - The path as an extended length path. - - The transaction. - Full pathname of the source path to convert. - The path format to use. - Options for controlling the operation. Note that on .NET 3.5 the TrimEnd option has no effect. - - - Returns a random folder name or file name. - A random folder name or file name. - - - Creates a uniquely named, zero-byte temporary file on disk and returns the full path of that file. - The full path of the temporary file. - - - Returns the path of the current user's temporary folder. - The path to the temporary folder, ending with a backslash. - - - [AlphaFS] Returns the path of the current user's temporary folder. - The folder name to append to the temporary folder. - The path to the temporary folder, combined with . - - - Represents a wrapper class for a handle used by the CM_Connect_Machine/CM_Disconnect_Machine Win32 API functions. - - - Initializes a new instance of the class. - - - Represents a wrapper class for a handle used by the FindFirstFile/FindNextFile Win32 API functions. - - - Constructor that prevents a default instance of this class from being created. - - - Constructor that prevents a default instance of this class from being created. - The handle. - true to reliably release the handle during the finalization phase; false to prevent - reliable release (not recommended). - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - Contains Shell32 information about a file. - - - Initializes a Shell32Info instance. - Shell32 is limited to MAX_PATH length. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - - - Initializes a Shell32Info instance. - Shell32 is limited to MAX_PATH length. - This constructor does not check if a file exists. This constructor is a placeholder for a string that is used to access the file in subsequent operations. - - The fully qualified name of the new file, or the relative file name. Do not end the path with the directory separator character. - Indicates the format of the path parameter(s). - - - Gets an handle to the Shell icon that represents the file. - Icon size or . Can also be combined with and others. - An handle to the Shell icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - - Gets the Shell command association from the registry. - The shell verb. - - Returns the associated file- or protocol-related Shell command from the registry or string.Empty if no association can be - found. - - - - Refreshes the state of the object. - - - Returns the path as a string. - The path. - - - Gets the Shell file or protocol association from the registry. - - - The attributes of the file object. - - - Gets the Shell command association from the registry. - - - Gets the Shell command association from the registry. - - - Gets the Shell DDE association from the registry. - - - Gets the Shell default icon association from the registry. - - - Represents the fully qualified path of the file. - - - Gets the Shell friendly application name association from the registry. - - - Gets the Shell friendly document name association from the registry. - - - Reflects the initialization state of the instance. - - - Gets the Shell "Open With" command association from the registry. - - - Class for CopyMoveResult that contains the results for the Copy or Move action. - - - Create a CopyMoveResult class instance for the Copy or Move action. - Indicates the source file or directory. - Indicates the destination file or directory. - Indicates if the action was canceled. - The error code encountered during the Copy or Move action. - - - The error code encountered during the Copy or Move action. - 0 (zero) indicates success. - - - The error message from the that was encountered during the Copy or Move action. - A message describing the error. - - - When true indicates that the Copy or Move action was canceled. - when the Copy/Move action was canceled. Otherwise . - - - Indicates the source file or directory. - - - Indicates the destination file or directory. - - - The total number of folders copied. - - - The total number of files copied. - - - The total number of bytes copied. - - - Information about the target of a symbolic link or mount point. - - - The print name. - - - The substitute name. - - - Used by MoveFileXxx.Flags that specify how a file or directory is to be moved. - - - No MoveOptions used, this fails when the file name already exists. - - - MOVE_FILE_REPLACE_EXISTSING - If the destination file name already exists, the function replaces its contents with the contents of the source file. - This value cannot be used if lpNewFileName or lpExistingFileName names a directory. - This value cannot be used if either source or destination names a directory. - - - - MOVE_FILE_COPY_ALLOWED - If the file is to be moved to a different volume, the function simulates the move by using the CopyFile and DeleteFile functions. - This value cannot be used with . - - - - MOVE_FILE_DELAY_UNTIL_REBOOT - - The system does not move the file until the operating system is restarted. - The system moves the file immediately after AUTOCHK is executed, but before creating any paging files. - - - Consequently, this parameter enables the function to delete paging files from previous startups. - This value can only be used if the process is in the context of a user who belongs to the administrators group or the LocalSystem account. - - This value cannot be used with . - - - - MOVE_FILE_WRITE_THROUGH - The function does not return until the file has actually been moved on the disk. - - Setting this value guarantees that a move performed as a copy and delete operation is flushed to disk before the function returns. - The flush occurs at the end of the copy operation. - - This value has no effect if is set. - - - - MOVE_FILE_CREATE_HARDLINK - Reserved for future use. - - - - MOVE_FILE_FAIL_IF_NOT_TRACKABLE - The function fails if the source file is a link source, but the file cannot be tracked after the move. - This situation can occur if the destination is a volume formatted with the FAT file system. - - - - The file or directory was not a reparse point. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - Provides access to a file system object, using Shell32. - - - Provides information for the IQueryAssociations interface methods, used by Shell32. - - - None. - - - Instructs not to map CLSID values to ProgID values. - - - Identifies the value of the supplied file parameter (3rd parameter of function GetFileAssociation()) as an executable file name. - If this flag is not set, the root key will be set to the ProgID associated with the .exe key instead of the executable file's ProgID. - - - Specifies that when an IQueryAssociation method does not find the requested value under the root key, it should attempt to retrieve the comparable value from the * subkey. - - - Specifies that when an IQueryAssociation method does not find the requested value under the root key, it should attempt to retrieve the comparable value from the Folder subkey. - - - Specifies that only HKEY_CLASSES_ROOT should be searched, and that HKEY_CURRENT_USER should be ignored. - - - Specifies that the return string should not be truncated. Instead, return an error value and the required size for the complete string. - - - - Instructs IQueryAssociations methods to verify that data is accurate. - This setting allows IQueryAssociations methods to read data from the user's hard disk for verification. - For example, they can check the friendly name in the registry against the one stored in the .exe file. - - Setting this flag typically reduces the efficiency of the method. - - - - Instructs IQueryAssociations methods to ignore Rundll.exe and return information about its target. - Typically IQueryAssociations methods return information about the first .exe or .dll in a command string. - If a command uses Rundll.exe, setting this flag tells the method to ignore Rundll.exe and return information about its target. - - - - Instructs IQueryAssociations methods not to fix errors in the registry, such as the friendly name of a function not matching the one found in the .exe file. - - - Specifies that the BaseClass value should be ignored. - - - Specifies that the "Unknown" ProgID should be ignored; instead, fail. - Introduced in Windows 7. - - - Specifies that the supplied ProgID should be mapped using the system defaults, rather than the current user defaults. - Introduced in Windows 8. - - - Specifies that the value is a protocol, and should be mapped using the current user defaults. - Introduced in Windows 8. - - - ASSOCSTR enumeration - Used by the AssocQueryString() function to define the type of string that is to be returned. - - - None. - - - A command string associated with a Shell verb. - - - - An executable from a Shell verb command string. - For example, this string is found as the (Default) value for a subkey such as HKEY_CLASSES_ROOT\ApplicationName\shell\Open\command. - If the command uses Rundll.exe, set the flag in the attributes parameter of IQueryAssociations::GetString to retrieve the target executable. - - - - The friendly name of a document type. - - - The friendly name of an executable file. - - - Ignore the information associated with the open subkey. - - - Look under the ShellNew subkey. - - - A template for DDE commands. - - - The DDE command to use to create a process. - - - The application name in a DDE broadcast. - - - The topic name in a DDE broadcast. - - - - Corresponds to the InfoTip registry value. - Returns an info tip for an item, or list of properties in the form of an IPropertyDescriptionList from which to create an info tip, such as when hovering the cursor over a file name. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Corresponds to the QuickTip registry value. This is the same as , except that it always returns a list of property names in the form of an IPropertyDescriptionList. - The difference between this value and is that this returns properties that are safe for any scenario that causes slow property retrieval, such as offline or slow networks. - Some of the properties returned from might not be appropriate for slow property retrieval scenarios. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Corresponds to the TileInfo registry value. Contains a list of properties to be displayed for a particular file type in a Windows Explorer window that is in tile view. - This is the same as , but, like , it also returns a list of property names in the form of an IPropertyDescriptionList. - The list of properties can be parsed with PSGetPropertyDescriptionListFromString. - - - - - Describes a general type of MIME file association, such as image and bmp, - so that applications can make general assumptions about a specific file type. - - - - - Returns the path to the icon resources to use by default for this association. - Positive numbers indicate an index into the dll's resource table, while negative numbers indicate a resource ID. - An example of the syntax for the resource is "c:\myfolder\myfile.dll,-1". - - - - - For an object that has a Shell extension associated with it, - you can use this to retrieve the CLSID of that Shell extension object by passing a string representation - of the IID of the interface you want to retrieve as the pwszExtra parameter of IQueryAssociations::GetString. - For example, if you want to retrieve a handler that implements the IExtractImage interface, - you would specify "{BB2E617C-0920-11d1-9A0B-00C04FC2D6C1}", which is the IID of IExtractImage. - - - - - For a verb invoked through COM and the IDropTarget interface, you can use this flag to retrieve the IDropTarget object's CLSID. - This CLSID is registered in the DropTarget subkey. - The verb is specified in the supplied file parameter in the call to IQueryAssociations::GetString. - - - - - For a verb invoked through COM and the IExecuteCommand interface, you can use this flag to retrieve the IExecuteCommand object's CLSID. - This CLSID is registered in the verb's command subkey as the DelegateExecute entry. - The verb is specified in the supplied file parameter in the call to IQueryAssociations::GetString. - - - - (No description available on MSDN) - Introduced in Windows 8. - - - The maximum defined value, used for validation purposes. - - - Shell32 FileAttributes structure, used to retrieve the different types of a file system object. - - - 0x000000000 - Get file system object large icon. - The flag must also be set. - - - 0x000000001 - Get file system object small icon. - The flag must also be set. - - - 0x000000002 - Get file system object open icon. - A container object displays an open icon to indicate that the container is open. - The and/or flag must also be set. - - - 0x000000004 - Get file system object Shell-sized icon. - If this attribute is not specified the function sizes the icon according to the system metric values. - - - 0x000000008 - Get file system object by its PIDL. - Indicate that the given file contains the address of an ITEMIDLIST structure rather than a path name. - - - 0x000000010 - Indicates that the given file should not be accessed. Rather, it should act as if the given file exists and use the supplied attributes. - This flag cannot be combined with the , or attributes. - - - 0x000000020 - Apply the appropriate overlays to the file's icon. - The flag must also be set. - - - 0x000000040 - Returns the index of the overlay icon. - The value of the overlay index is returned in the upper eight bits of the iIcon member of the structure specified by psfi. - - - 0x000000100 - Retrieve the handle to the icon that represents the file and the index of the icon within the system image list. The handle is copied to the member of the structure, and the index is copied to the member. - - - 0x000000200 - Retrieve the display name for the file. The name is copied to the member of the structure. - The returned display name uses the long file name, if there is one, rather than the 8.3 form of the file name. - - - 0x000000400 - Retrieve the string that describes the file's type. - - - 0x000000800 - Retrieve the item attributes. The attributes are copied to the member of the structure. - Will touch every file, degrading performance. - - - 0x000001000 - Retrieve the name of the file that contains the icon representing the file specified by pszPath. The name of the file containing the icon is copied to the member of the structure. The icon's index is copied to that structure's member. - - - 0x000002000 - Retrieve the type of the executable file if pszPath identifies an executable file. - This flag cannot be specified with any other attributes. - - - 0x000004000 - Retrieve the index of a system image list icon. - - - 0x000008000 - Add the link overlay to the file's icon. - The flag must also be set. - - - 0x000010000 - Blend the file's icon with the system highlight color. - - - 0x000020000 - Modify to indicate that contains specific attributes that are desired. - This flag cannot be specified with the attribute. Will touch every file, degrading performance. - - - SHFILEINFO structure, contains information about a file system object. - - - A handle to the icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - - The index of the icon image within the system image list. - - - An array of values that indicates the attributes of the file object. - - - The name of the file as it appears in the Windows Shell, or the path and file name of the file that contains the icon representing the file. - - - The type of file. - - - SFGAO - Attributes that can be retrieved from a file system object. - - - 0x00000000 - None. - - - 0x00000001 - The specified items can be copied. - - - 0x00000002 - The specified items can be moved. - - - 0x00000004 - Shortcuts can be created for the specified items. - - - 0x00000008 - The specified items can be bound to an IStorage object through IShellFolder::BindToObject. For more information about namespace manipulation capabilities, see IStorage. - - - 0x00000010 - The specified items can be renamed. Note that this value is essentially a suggestion; not all namespace clients allow items to be renamed. However, those that do must have this attribute set. - - - 0x00000020 - The specified items can be deleted. - - - 0x00000040 - The specified items have property sheets. - - - 0x00000100 - The specified items are drop targets. - - - 0x00001000 - The specified items are system items. - Windows 7 and later. - - - 0x00002000 - The specified items are encrypted and might require special presentation. - - - 0x00004000 - Accessing the item (through IStream or other storage interfaces) is expected to be a slow operation. - - - 0x00008000 - The specified items are shown as dimmed and unavailable to the user. - - - 0x00010000 - The specified items are shortcuts. - - - 0x00020000 - The specified objects are shared. - - - 0x00040000 - The specified items are read-only. In the case of folders, this means that new items cannot be created in those folders. - - - 0x00080000 - The item is hidden and should not be displayed unless the Show hidden files and folders option is enabled in Folder Settings. - - - 0x00100000 - The items are nonenumerated items and should be hidden. They are not returned through an enumerator such as that created by the IShellFolder::EnumObjects method. - - - 0x00200000 - The items contain new content, as defined by the particular application. - - - 0x00400000 - Indicates that the item has a stream associated with it. - - - 0x00800000 - Children of this item are accessible through IStream or IStorage. - - - 0x01000000 - When specified as input, instructs the folder to validate that the items contained in a folder or Shell item array exist. - - - 0x02000000 - The specified items are on removable media or are themselves removable devices. - - - 0x04000000 - The specified items are compressed. - - - 0x08000000 - The specified items can be hosted inside a web browser or Windows Explorer frame. - - - 0x10000000 - The specified folders are either file system folders or contain at least one descendant (child, grandchild, or later) that is a file system folder. - - - 0x20000000 - The specified items are folders. - - - 0x40000000 - The specified folders or files are part of the file system (that is, they are files, directories, or root directories). - - - 0x80000000 - The specified folders have subfolders. - - - Used by method UrlIs() to define a URL type. - - - Is the URL valid? - - - Is the URL opaque? - - - Is the URL a URL that is not typically tracked in navigation history? - - - Is the URL a file URL? - - - Attempt to determine a valid scheme for the URL. - - - Does the URL string end with a directory? - - - Does the URL have an appended query string? - - - Destroys an icon and frees any memory the icon occupied. - An handle to an icon. - - - Gets the file or protocol that is associated with from the registry. - A path to the file. - The associated file- or protocol-related string from the registry or string.Empty if no association can be found. - - - Gets the content-type that is associated with from the registry. - A path to the file. - The associated file- or protocol-related content-type from the registry or string.Empty if no association can be found. - - - Gets the default icon that is associated with from the registry. - A path to the file. - The associated file- or protocol-related default icon from the registry or string.Empty if no association can be found. - - - Gets the friendly application name that is associated with from the registry. - A path to the file. - The associated file- or protocol-related friendly application name from the registry or string.Empty if no association can be found. - - - Gets the friendly document name that is associated with from the registry. - A path to the file. - The associated file- or protocol-related friendly document name from the registry or string.Empty if no association can be found. - - - Gets an handle to the Shell icon that represents the file. - Caller is responsible for destroying this handle with DestroyIcon() when no longer needed. - - The path to the file system object which should not exceed maximum path length. Both absolute and - relative paths are valid. - - - Icon size or . Can also be combined - with and others. - - An handle to the Shell icon that represents the file, or IntPtr.Zero on failure. - - - Retrieves information about an object in the file system, such as a file, folder, directory, or drive root. - A struct instance. - - You should call this function from a background thread. - Failure to do so could cause the UI to stop responding. - Unicode path are supported. - - The path to the file system object which should not exceed the maximum path length. Both absolute and relative paths are valid. - A attribute. - One ore more attributes. - - suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - - - Retrieves an instance of containing information about the specified file. - A path to the file. - A class instance. - - - Retrieves an instance of containing information about the specified file. - A path to the file. - Indicates the format of the path parameter(s). - A class instance. - - - Gets the "Open With" command that is associated with from the registry. - A path to the file. - The associated file- or protocol-related "Open With" command from the registry or string.Empty if no association can be found. - - - Gets the Shell command that is associated with from the registry. - A path to the file. - The associated file- or protocol-related Shell command from the registry or string.Empty if no association can be found. - - - Converts a file URL to a Microsoft MS-DOS path. - The file URL. - - The Microsoft MS-DOS path. If no path can be created, string.Empty is returned. - If is , will also be returned. - - - - Creates a path from a file URL. - The URL. - - The file path. If no path can be created, string.Empty is returned. - If is , will also be returned. - - - - Determines whether a path to a file system object such as a file or folder is valid. - The full path of maximum length the maximum path length to the object to verify. - if the file exists; otherwise - - - Tests whether a URL is a specified type. - The URL. - - - For all but one of the URL types, UrlIs returns if the URL is the specified type, or otherwise. - If UrlIs is set to , UrlIs will attempt to determine the URL scheme. - If the function is able to determine a scheme, it returns , or otherwise. - - - - Converts a Microsoft MS-DOS path to a canonicalized URL. - The full MS-DOS path of maximum length . - - The URL. If no URL can be created string.Empty is returned. - If is , will also be returned. - - - - Tests a URL to determine if it is a file URL. - The URL. - if the URL is a file URL, or otherwise. - - - Returns whether a URL is a URL that browsers typically do not include in navigation history. - The URL. - if the URL is a URL that is not included in navigation history, or otherwise. - - - Returns whether a URL is opaque. - The URL. - if the URL is opaque, or otherwise. - - - Searches for and retrieves a file or protocol association-related string from the registry. - A path to a file. - One or more attributes. Only one "InitXXX" attribute can be used. - A attribute. - The associated file- or protocol-related string from the registry or string.Empty if no association can be found. - - - - Retrieve information about an object in the file system, such as a file, folder, directory, or drive root. - A struct instance. - - You should call this function from a background thread. - Failure to do so could cause the UI to stop responding. - Unicode path are not supported. - - The path to the file system object which should not exceed the maximum path length in length. Both absolute and relative paths are valid. - A attribute. - A attribute. - Checks that the path contains only valid path-characters. - - suppress any Exception that might be thrown as a result from a failure, - such as ACLs protected directories or non-accessible reparse points. - - - - Indicates whether the link target is a file or directory. - Used by Win32 API CreateSymbolicLink()/CreateSymbolicLinkTransacted() - - - The link target is a file. - - - The link target is a directory. - - - Represents information about a symbolic link. - - - Gets the type of the link. - The type of the link. - - - Specifies the type of a symbolic link. - - - The symbolic link is absolute. - - - The symbolic link is relative. - - - The function attempted to use a name that is reserved for use by another transaction. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - The function attempted to use a name that is reserved for use by another transaction. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - The remote server or share does not support transacted file operations. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The object that holds the serialized object data. - The contextual information about the source or destination. - - - The transaction handle associated with this operation is not valid. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - A KTM transaction object for use with the transacted operations in - - - Initializes a new instance of the class, internally using the specified . - This method allows the usage of methods accepting a with an instance of . - - The transaction to use for any transactional operations. - - - Initializes a new instance of the class with a default security descriptor, infinite timeout and no description. - - - Initializes a new instance of the class with a default security descriptor. - The time, in milliseconds, when the transaction will be aborted if it has not already reached the prepared state. - A user-readable description of the transaction. This parameter may be . - - - Initializes a new instance of the class. - The security descriptor. - The time, in milliseconds, when the transaction will be aborted if it has not already reached the prepared state. - Specify 0 to provide an infinite timeout. - A user-readable description of the transaction. This parameter may be . - - - Requests that the specified transaction be committed. - - - - - - Requests that the specified transaction be rolled back. This function is synchronous. - - - - - Gets the safe handle. - The safe handle. - - - Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. - - - Represents a wrapper class for a handle used by the FindFirstFile/FindNextFile Win32 API functions. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - Represents a wrapper class for a handle used by the FindFirstVolumeMountPoint/FindVolumeMountPointClose methods of the Win32 API. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . - - - - Represents a wrapper class for a handle used by the FindFirstVolume/FindNextVolume methods of the Win32 API. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The handle. - [owns handle]. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - - Provides a concrete implementation of SafeHandle supporting transactions. - - - Initializes a new instance of the class. - - - When overridden in a derived class, executes the code required to free the handle. - if the handle is released successfully; otherwise, in the event of a catastrophic failure, . In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant. - - - It is too late to perform the requested operation, since the Transaction has already been aborted. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The info. - The context. - - - It is too late to perform the requested operation, since the Transaction has already been committed. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The object that holds the serialized object data. - The contextual information about the source or destination. - - - The exception that is thrown when an attempt to create a file or directory that already exists was made. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class. - The message. - - - Initializes a new instance of the class. - The message. - The inner exception. - - - Initializes a new instance of the class. - The data for serializing or deserializing the object. - The source and destination for the object. - - - Static class providing utility methods for working with Microsoft Windows devices and volumes. - - - Defines, redefines, or deletes MS-DOS device names. - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - An MS-DOS path that will implement this device. - - - Defines, redefines, or deletes MS-DOS device names. - - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - - - >An MS-DOS path that will implement this device. If parameter has the - flag specified, is used as is. - - - The controllable aspects of the DefineDosDevice function, flags which will be combined with the - default. - - - - Deletes an MS-DOS device name. - An MS-DOS device name specifying the device to delete. - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - - Deletes an MS-DOS device name. - An MS-DOS device name string specifying the device to delete. - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - The controllable aspects of the DefineDosDevice function flags which will be combined with the - default. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - - Retrieves a list of all existing MS-DOS device names. - An with one or more existing MS-DOS device names. - - - Retrieves a list of all existing MS-DOS device names. - - (Optional, default: ) An MS-DOS device name string specifying the target of the query. This parameter can be - "sort". In that case a sorted list of all existing MS-DOS device names is returned. This parameter can be . - In that case, the function will store a list of all existing MS-DOS device names into the buffer. - - An with or more existing MS-DOS device names. - - - - Retrieves information about MS-DOS device names. The function can obtain the current mapping for a particular MS-DOS device name. - The function can also obtain a list of all existing MS-DOS device names. - - - An MS-DOS device name string, or part of, specifying the target of the query. This parameter can be . In that - case, the QueryDosDevice function will store a list of all existing MS-DOS device names into the buffer. - - - (Optional, default: ) If options[0] = a sorted list will be returned. - - An with one or more existing MS-DOS device names. - - - Gets the name of the file system, such as NTFS or FAT32. - Use DriveFormat to determine what formatting a drive uses. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - The name of the file system on the specified drive or on failure or if not available. - - - Gets the drive letter from an MS-DOS device name. For example: "\Device\HarddiskVolume2" returns "C:\". - An MS-DOS device name. - The drive letter from an MS-DOS device name. - - - - Determines, based on the root of the current directory, whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network - drive. - - A object. - - - Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive. - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\" - A object. - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, the total - amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - A class instance. - - - - Retrieves information about the amount of space that is available on a disk volume, which is the total amount of space, the total - amount of free space, and the total amount of free space available to the user that is associated with the calling thread. - - The calling application must have FILE_LIST_DIRECTORY access rights for this directory. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - - gets both size- and disk cluster information. Get only disk cluster information, - Get only size information. - - A class instance. - - - Gets a value indicating whether a drive is ready. - - A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - if is ready; otherwise, . - - - Deletes the label of the file system volume that is the root of the current directory. - - - - Deletes the label of a file system volume. - - The root directory of a file system volume. This is the volume the function will remove the label. - - - Deletes a Drive letter or mounted folder. - Deleting a mounted folder does not cause the underlying directory to be deleted. - - If the parameter is a directory that is not a mounted folder, the function does nothing. The - directory is not deleted. - - - It's not an error to attempt to unmount a volume from a volume mount point when there is no volume actually mounted at that volume - mount point. - - The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\. - - - - Returns an enumerable collection of of all mounted folders (volume mount points) on the specified volume. - - - - A containing the volume . - An enumerable collection of of all volume mount points on the specified volume. - - - - Returns an enumerable collection of drive letters and mounted folder paths for the specified volume. - - - - A volume path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\. - An enumerable collection of containing the path names for the specified volume. - - - Returns an enumerable collection of volumes on the computer. - An enumerable collection of volume names on the computer. - - - - Get the unique volume name for the given path. - - - - A path string. Both absolute and relative file and directory names, for example "..", is acceptable in this path. If you specify a - relative file or directory name without a volume qualifier, GetUniqueVolumeNameForPath returns the Drive letter of the current - volume. - - - Returns the unique volume name in the form: "\\?\Volume{GUID}\", - or on error or if unavailable. - - - - Retrieves the Win32 Device name from the Volume name. - - Name of the Volume. - - The Win32 Device name from the Volume name (for example: "\Device\HarddiskVolume2"), or on error or if - unavailable. - - - - Gets the shortest display name for the specified . - This method basically returns the shortest string returned by - A volume path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\. - - The shortest display name for the specified volume found, or if no display names were found. - - - - - Retrieves a volume path for the volume that is associated with the specified volume mount point (drive letter, - volume GUID path, or mounted folder). - - - - The path of a mounted folder (for example, "Y:\MountX\") or a drive letter (for example, "X:\"). - - The unique volume name of the form: "\\?\Volume{GUID}\". - - - - Tranlates DosDevicePath to a Volume GUID. For example: "\Device\HarddiskVolumeX\path\filename.ext" can translate to: "\path\ - filename.ext" or: "\\?\Volume{GUID}\path\filename.ext". - - A DosDevicePath, for example: \Device\HarddiskVolumeX\path\filename.ext. - A translated dos path. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - A path that contains the root directory. - A instance describing the volume associatied with the specified root directory. - - - Retrieves information about the file system and volume associated with the specified root file or directorystream. - An instance to a handle. - A instance describing the volume associatied with the specified root directory. - - - Retrieve the label of a file system volume. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - - The the label of the file system volume. This function can return string.Empty since a volume label is generally not - mandatory. - - - - Retrieves the volume mount point where the specified path is mounted. - - The path to the volume, for example: "C:\Windows". - - Returns the nearest volume root path for a given directory. - The volume path name, for example: "C:\Windows" returns: "C:\". - - - - Determines whether the volume of two file system objects is the same. - The first filesystem ojbect with full path information. - The second file system object with full path information. - if both filesytem objects reside on the same volume, otherwise. - - - Determines whether the specified volume name is a defined volume on the current computer. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\". - - on success, otherwise. - - - Sets the label of the file system volume that is the root of the current directory. - - A name for the volume. - - - Sets the label of a file system volume. - - A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\" - If this parameter is , the function uses the current drive. - - - A name for the volume. - If this parameter is , the function deletes any existing label - from the specified volume and does not assign a new label. - - - - Associates a volume with a Drive letter or a directory on another volume. - - - - The user-mode path to be associated with the volume. This may be a Drive letter (for example, "X:\") - or a directory on another volume (for example, "Y:\MountX\"). - - A containing the volume . - - - Defines, redefines, or deletes MS-DOS device names. - - - defines a new MS-DOS device. deletes a previously defined MS-DOS device. - - - An MS-DOS device name string specifying the device the function is defining, redefining, or deleting. - - - A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the - flag is specified, in which case this string is a path string. - - - The controllable aspects of the DefineDosDevice function, flags which will be combined with the - default. - - - Only delete MS-DOS device on an exact name match. If is , - must be the same path used to create the mapping. - - - on success, otherwise. - - - Deletes a Drive letter or mounted folder. - - It's not an error to attempt to unmount a volume from a volume mount point when there is no volume actually mounted at that volume mount point. - Deleting a mounted folder does not cause the underlying directory to be deleted. - - - The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - If completed successfully returns , otherwise the last error number. - - - Contains information about a filesystem Volume. - - - Initializes a VolumeInfo instance. - - - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: \\server\share. - - - Initializes a VolumeInfo instance. - A valid drive path or drive letter. This can be either uppercase or lowercase, 'a' to 'z' or a network share in the format: "\\server\share". - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Initializes a VolumeInfo instance. - An instance to a handle. - - - Initializes a VolumeInfo instance. - An instance to a handle. - Refreshes the state of the object. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Refreshes the state of the object. - - - Returns the full path of the volume. - A string that represents this instance. - - - The specified volume supports preserved case of file names when it places a name on disk. - - - The specified volume supports case-sensitive file names. - - - The specified volume supports file-based compression. - - - Gets the name of the file system, for example, the FAT file system or the NTFS file system. - The name of the file system. - - - The full path to the volume. - - - The volume GUID. - - - Gets the maximum length of a file name component that the file system supports. - The maximum length of a file name component that the file system supports. - - - Gets the label of the volume. - The label of the volume. - This property is the label assigned to the volume, such "MyDrive" - - - The specified volume supports named streams. - - - The specified volume preserves and enforces access control lists (ACL). - - - The specified volume is read-only. - - - The specified volume supports a single sequential write. - - - Gets the volume serial number that the operating system assigns when a hard disk is formatted. - The volume serial number that the operating system assigns when a hard disk is formatted. - - - The specified volume supports the Encrypted File System (EFS). - - - The specified volume supports extended attributes. - - - The specified volume supports hard links. - - - The specified volume supports object identifiers. - - - The file system supports open by FileID. - - - The specified volume supports remote storage. (This property does not appear on MSDN) - - - The specified volume supports re-parse points. - - - The specified volume supports sparse files. - - - The specified volume supports transactions. - - - The specified volume supports update sequence number (USN) journals. - - - The specified volume supports Unicode in file names as they appear on disk. - - - The specified volume is a compressed volume, for example, a DoubleSpace volume. - - - The specified volume supports disk quotas. - - - Contains information about a Distributed File System (DFS) root or link. This class cannot be inherited. - This structure contains the name, status, GUID, time-out, number of targets, and information about each target of the root or link. - - - - Initializes a new instance of the class which acts as a wrapper for a DFS root or link target. - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - An initialized instance. - - - Returns the Universal Naming Convention (UNC) path of the DFS root or link. - A string that represents this instance. - - - The instance of the DFS root or link. - - - The comment of the DFS root or link. - - - The Universal Naming Convention (UNC) path of the DFS root or link. - - - Specifies the GUID of the DFS root or link. - - - The collection of DFS targets of the DFS root or link. - - - An enum that specifies a set of bit flags that describe the DFS root or link. - - - Specifies the time-out, in seconds, of the DFS root or link. - - - Specifies a set of flags that describe specific properties of a DFS namespace, root, or link. - - - For domain-based DFS namespaces, this member specifies the size of the corresponding Active Directory data blob, in bytes. - For stand-alone DFS namespaces, this field specifies the size of the metadata stored in the registry, - including the key names and value names, in addition to the specific data items associated with them. This field is valid for DFS roots only. - - - - Pointer to a SECURITY_DESCRIPTOR structure that specifies a self-relative security descriptor to be associated with the DFS link's reparse point. - This field is valid for DFS links only. - - - - Contains information about a DFS root or link target in a DFS namespace or from the cache maintained by the DFS client. - This class cannot be inherited. - - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - - - Initializes a new instance of the class, which acts as a wrapper for a DFS root or link target. - An initialized instance. - - - The share name of the DFS root target or link target. - A string that represents this instance. - - - The server name of the DFS root target or link target. - - - The share name of the DFS root target or link target. - - - An enum of the DFS root target or link target. - - - Contains a DFS target's priority class and rank. - - - Specifies the priority rank value of the target. The default value is 0, which indicates the highest priority rank within a priority class. - - - A set of bit flags that describe specific properties of a DFS namespace, root, or link. - - - No property flag. - - - DFS_PROPERTY_FLAG_INSITE_REFERRALS - - Scope: Domain roots, stand-alone roots, and links. - If this flag is set at the DFS root, it applies to all links; otherwise, the value of this flag is considered for each individual link. - - - When this flag is set, a DFS referral response from a DFS server for a DFS root or link with the "INSITE" option enabled contains only - those targets which are in the same site as the DFS client requesting the referral. - Targets in the two global priority classes are always returned, regardless of their site location. - - - - - DFS_PROPERTY_FLAG_ROOT_SCALABILITY - - Scope: The entire DFS namespace for a domain-based DFS namespace only. - - - By default, a DFS root target server polls the PDS to detect changes to the DFS metadata. - To prevent heavy server load on the PDC, root scalability can be enabled for the DFS namespace. - Setting this flag will cause the DFS server to poll the nearest domain controller instead of the PDC for DFS metadata changes for the common namespace. - Note that any changes made to the metadata must still occur on the PDC, however. - - - - - DFS_PROPERTY_FLAG_SITE_COSTING - - Scope: The entire DFS namespace for both domain-based and stand-alone DFS namespaces. - - - By default, targets returned in a referral response from a DFS server to a DFS client for a DFS root or link - consists of two groups: targets in the same site as the client, and targets outside the site. - - - If site-costing is enabled for the Active Directory, the response can have more than two groups, - with each group containing targets with the same site cost for the specific DFS client requesting the referral. - The groups are ordered by increasing site cost. For more information about how site-costing is used to prioritize targets. - - - - - DFS_PROPERTY_FLAG_TARGET_FAILBACK - - Scope: Domain-based DFS roots, stand-alone DFS roots, and DFS links. - If this flag is set at the DFS root, it applies to all links; otherwise, the value of this flag is considered for each individual link. - - - When this flag is set, optimal target failback is enabled for V4 DFS clients, - allowing them to fail back to an optimal target after failing over to a non-optimal one. - The target failback setting is provided to the DFS client in a V4 referral response by a DFS server. - - - - - DFS_PROPERTY_FLAG_CLUSTER_ENABLED - Scope: Stand-alone DFS roots and links only. - The DFS root is clustered to provide high availability for storage failover. - - - - DFS_PROPERTY_FLAG_ABDE - Scope: Domain-based DFS roots and stand-alone DFS roots. - When this flag is set, Access-Based Directory Enumeration (ABDE) mode support is enabled on the entire DFS root target share of the DFS namespace. - - - - Defines the set of possible DFS target priority class settings. - - - The priority class is not valid. - - - The middle or "normal" site cost priority class for a DFS target. - - - The highest priority class for a DFS target. Targets assigned this class receive global preference. - - - The highest site cost priority class for a DFS target. Targets assigned this class receive the most preference among targets of the same site cost for a given DFS client. - - - The lowest site cost priority class for a DFS target. Targets assigned this class receive the least preference among targets of the same site cost for a given DFS client. - - - The lowest level of priority class for a DFS target. Targets assigned this class receive the least preference globally. - - - The information level. - - - No specific information level used. - - - Contains information about the shared resource, including the name and type of the resource, and a comment associated with the resource. - - - Contains information about the shared resource, including the name, type, and permissions of the resource, comments associated with the resource, - the maximum number of concurrent connections, the number of current connections, the local path for the resource, and a password for the current connection. - - - - Contains information about the shared resource, including the server name, name of the resource, type, and permissions, - the number of connections, and other pertinent information. - - - - Contains information about the shared resource. - - - NETRESOURCE structure. - ResourceUsage: A set of bit flags describing how the resource can be used. - - Note that this member can be specified only if the member is equal to . - - - RESOURCEUSAGE_CONNECTABLE - The resource is a connectable resource. - The name pointed to by the lpRemoteName member can be passed to the WNetAddConnection function to make a network connection. - - - - RESOURCEUSAGE_CONTAINER - The resource is a container resource. - The name pointed to by the lpRemoteName member can be passed to the WNetAddConnection function to make a network connection. - - - - RESOURCEUSAGE_NOLOCALDEVICE - The resource is not a local device. - - - - RESOURCEUSAGE_SIBLING - The resource is a sibling. - This value is not used by Windows. - - - - RESOURCEUSAGE_ATTACHED - The resource must be attached. - This value specifies that a function to enumerate this resource should fail - if the caller is not authenticated, even if the network permits enumeration without authentication. - - - - RESOURCEUSAGE_ALL - Setting this value is equivalent to setting: , , and . - - - - NETRESOURCE structure. - ResourceType: The type of resource. - - If a network provider cannot distinguish between - print and disk resources, it can enumerate all resources. - - - - - RESOURCETYPE_ANY - ResourceType: All resources. - - If a network provider cannot distinguish between print and disk resources, it can enumerate all resources. - This value cannot be combined with or . - - - - - RESOURCETYPE_DISK - All disk resources. - - - - RESOURCETYPE_PRINT - All print resources. - - - - NETRESOURCE structure. - ResourceScope: The scope of the enumeration. - - - - RESOURCE_CONNECTED - Enumerate all currently connected resources. - The function ignores the parameter. - - - - RESOURCE_GLOBALNET - Enumerate all resources on the network. - - - - RESOURCE_REMEMBERED - Enumerate all remembered (persistent) connections. - The function ignores the parameter. - - - - RESOURCE_RECENT - - - RESOURCE_CONTEXT - Enumerate only resources in the network context of the caller. Specify this value for a Network Neighborhood view. - The function ignores the parameter. - - - - The display options for the network object in a network browsing user interface. - - - RESOURCEDISPLAYTYPE_GENERIC - The method used to display the object does not matter. - - - - RESOURCEDISPLAYTYPE_DOMAIN - The object should be displayed as a domain. - - - - RESOURCEDISPLAYTYPE_SERVER - The object should be displayed as a server. - - - - RESOURCEDISPLAYTYPE_SHARE - The object should be displayed as a share - - - - RESOURCEDISPLAYTYPE_FILE - The object should be displayed as a file. - - - - RESOURCEDISPLAYTYPE_GROUP - The object should be displayed as a group. - - - - RESOURCEDISPLAYTYPE_NETWORK - The object should be displayed as a network. - - - - RESOURCEDISPLAYTYPE_ROOT - The object should be displayed as a logical root for the entire network. - - - - RESOURCEDISPLAYTYPE_SHAREADMIN - The object should be displayed as a administrative share. - - - - RESOURCEDISPLAYTYPE_DIRECTORY - The object should be displayed as a directory. - - - - RESOURCEDISPLAYTYPE_TREE - The object should be displayed as a tree. - - - - RESOURCEDISPLAYTYPE_NDSCONTAINER - The object should be displayed as a Netware Directory Service container. - - - - Used by function WNetUseConnection(); Set of bit flags describing the connection. This parameter can be any combination of the following values. - - - No Connect options are used. - - - This flag instructs the operating system to store the network resource connection. If this bit flag is set, the operating system automatically attempts to restore the connection when the user logs on. The system remembers only successful connections that redirect local devices. It does not remember connections that are unsuccessful or deviceless connections. - - - If this flag is set, the operating system may interact with the user for authentication purposes. - - - This flag instructs the system not to use any default settings for user names or passwords without offering the user the opportunity to supply an alternative. This flag is ignored unless is also set. - - - This flag forces the redirection of a local device when making the connection. - - - If this flag is set, and the operating system prompts for a credential, the credential should be saved by the credential manager. If the credential manager is disabled for the caller's logon session, or if the network provider does not support saving credentials, this flag is ignored. This flag is also ignored unless you set the "CommandLine" flag. - - - Contains the name and type (domain-based or stand-alone) of a DFS namespace. - Minimum supported client: Windows XP with SP1 [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - - DFS_VOLUME_FLAVOR_STANDALONE - Specifies a stand-alone DFS namespace. - - - - DFS_VOLUME_FLAVOR_AD_BLOB - Specifies a domain-based DFS namespace. - - - - DFS_VOLUME_FLAVORS bitmask (0x00000300) - Used to extract the DFS namespace flavor. - - - - The WNetCancelConnection function cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - The WNetGetUniversalName function takes a drive-based path for a network resource and returns an information structure that contains a more universal form of the name. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - The WNetUseConnection function creates a connection to a network resource. The function can redirect a local device to a network resource. - - If the function succeeds, the return value is - If the function fails, the return value is a system error code. - - - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Lists all connections made to a shared resource on the server or all connections established from a particular computer. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - If there is more than one user using this connection, then it is possible to get more than one structure for the same connection, but with a different user name. - Administrator, Server or Print Operator, or Power User group membership is required to successfully execute the NetConnectionEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Forces a resource to close. This function can be used when an error prevents closure by any other means. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - You should use NetFileClose with caution because it does not write data cached on the client system to the file before closing the file. - Only members of the Administrators or Server Operators local group can successfully execute the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Returns information about some or all open files on a server, depending on the parameters specified. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - Only members of the Administrators or Server Operators local group can successfully execute the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves information about each (hidden) Server Message Block (SMB) resource/share on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - For interactive users (users who are logged on locally to the machine), no special group membership is required to execute the NetShareEnum function. - For non-interactive users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareEnum function at levels 2, 502, and 503. No special group membership is required for level 0 or level 1 calls. - This function applies only to Server Message Block (SMB) shares. - Windows Server 2003 and Windows XP: For all users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareEnum function at levels 2 and 502. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - Retrieves information about a particular Server Message Block (SMB) shared resource on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - For interactive users (users who are logged on locally to the machine), no special group membership is required to execute the NetShareGetInfo function. - For non-interactive users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareGetInfo function at levels 2, 502, and 503. - This function applies only to Server Message Block (SMB) shares. - Windows Server 2003 and Windows XP: For all users, Administrator, Power User, Print Operator, or Server Operator group membership is required to successfully execute the NetShareGetInfo function at levels 2 and 502. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - The NetServerDiskEnum function retrieves a list of disk drives on a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - The function returns an array of three-character strings (a drive letter, a colon, and a terminating null character). - Only members of the Administrators or Server Operators local group can successfully execute the NetServerDiskEnum function on a remote computer. - Minimum supported client: Windows 2000 Professional [desktop apps only] - Minimum supported server: Windows 2000 Server [desktop apps only] - - - - Enumerates the Distributed File System (DFS) namespaces hosted on a server or DFS links of a namespace hosted by a server. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsEnum function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - Retrieves information about a Distributed File System (DFS) root or link from the cache maintained by the DFS client. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsGetClientInfo function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - Retrieves information about a specified Distributed File System (DFS) root or link in a DFS namespace. - - If the function succeeds, the return value is NERR_Success. - If the function fails, the return value is a system error code. - - - No special group membership is required for using the NetDfsGetInfo function. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2003 - - - - A constant of type DWORD that is set to –1. This value is valid as an input parameter to any method in section 3.1.4 that takes a PreferedMaximumLength parameter. When specified as an input parameter, this value indicates that the method MUST allocate as much space as the data requires. - MSDN "2.2.2.2 MAX_PREFERRED_LENGTH": http://msdn.microsoft.com/en-us/library/cc247107.aspx - - - Contains the name, status, GUID, time-out, property flags, metadata size, DFS target information, link reparse point security descriptor, and a list of DFS targets for a root or link. - Minimum supported client: Windows Vista with SP1 - Minimum supported server: Windows Server 2008 - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - The comment associated with the DFS root or link. - - - A that specifies a set of bit flags that describe the DFS root or link. - - - Specifies the time-out, in seconds, of the DFS root or link. - - - Specifies the GUID of the DFS root or link. - - - Specifies a set of flags that describe specific properties of a DFS namespace, root, or link. - - - For domain-based DFS namespaces, this member specifies the size of the corresponding Active Directory data blob, in bytes. - For stand-alone DFS namespaces, this field specifies the size of the metadata stored in the registry, - including the key names and value names, in addition to the specific data items associated with them. - This field is valid for DFS roots only. - - - - This member is reserved for system use. - - - Pointer to a SECURITY_DESCRIPTOR structure that specifies a self-relative security descriptor to be associated with the DFS link's reparse point. - This field is valid for DFS links only. - - - - Specifies the number of DFS targets. - - - An array of structures. - - - Contains the priority class and rank of a specific DFS target. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 - - - DFS_TARGET_PRIORITY_CLASS enumeration value that specifies the priority class of the target. - - - Specifies the priority rank value of the target. The default value is 0, which indicates the highest priority rank within a priority class. - - - This member is reserved and must be zero. - - - Contains information about a DFS target, including the DFS target server name and share name as well as the target's state and priority. - Minimum supported client: Windows Vista - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 - - - State of the target. - - - The DFS root target or link target server name. - - - The DFS root target or link target share name. - - - DFS_TARGET_PRIORITY structure that contains a DFS target's priority class and rank. - - - Contains information about a network resource. - The NETRESOURCE structure is returned during an enumeration of network resources. - The NETRESOURCE structure is also specified when making or querying - a network connection with calls to various Windows Networking functions. - - - - The scope of the enumeration. - - - The type of resource - - - The display options for the network object in a network browsing user interface. - - - A set of bit flags describing how the resource can be used. - - - If the member is equal to or , - this member is a pointer to a -terminated character string that specifies the name of a local device. - This member is if the connection does not use a device. - - - - If the entry is a network resource, this member is a that specifies the remote network name. - If the entry is a current or persistent connection, member points to - the network name associated with the name pointed to by the member. - The can be characters in length, - and it must follow the network provider's naming conventions. - - - - A that contains a comment supplied by the network provider. - - - A that contains the name of the provider that owns the resource. - This member can be if the provider name is unknown. - - - - Contains the identifier and other pertinent information about files, devices, and pipes. - This structure is only for use with the NetFileEnum function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The identification number assigned to the resource when it is opened. - - - The access permissions associated with the opening application. This member can be one or more of the following values. - - - The number of file locks on the file, device, or pipe. - - - The path of the opened resource. - - - Specifies which user (on servers that have user-level security) or which computer (on servers that have share-level security) opened the resource. - - - Contains the name of a domain-based Distributed File System (DFS) namespace. - This structure is only for use with the NetDfsEnum, NetDfsGetClientInfo, and NetDfsGetInfo functions. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a domain-based DFS namespace. - - - Contains the name and type (domain-based or stand-alone) of a DFS namespace. - The DFS functions use the structure to enumerate DFS namespaces hosted on a machine. - Minimum supported client: Windows XP with SP1 [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Value that specifies the type of the DFS namespace. This member can be one of the values. - - - The name of a DFS namespace. - This member can have one of the following two formats: - The first format is: \ServerName\DfsName - where ServerName is the name of the root target server that hosts the stand-alone DFS namespace and DfsName is the name of the DFS namespace. - The second format is: - \DomainName\DomDfsName - where DomainName is the name of the domain that hosts the domain-based DFS namespace and DomDfsname is the name of the DFS namespace. - - - - Contains path and name information for a network resource. - - - Identifies a network resource. - - - The name of a network connection. - - - The remaing path. - - - Contains the identification number of a connection, number of open files, connection time, number of users on the connection, and the type of connection. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Specifies a connection identification number. - - - A combination of values that specify the type of connection made from the local device name to the shared resource. - - - Specifies the number of files currently open as a result of the connection. - - - Specifies the number of users on the connection. - - - Specifies the number of seconds that the connection has been established. - - - If the server sharing the resource is running with user-level security, the UserName member describes which user made the connection. If the server is running with share-level security, coni1_username describes which computer (computername) made the connection. - Note that Windows does not support share-level security. - - - String that specifies either the share name of the server's shared resource or the computername of the client. The value of this member depends on which name was specified as the qualifier parameter to the NetConnectionEnum function. - - - Contains information about the shared resource. - This structure can be retrieved by calling the NetShareGetInfo function. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - A bitmask of flags that specify information about the shared resource. - - - Contains information about the shared resource, including the name and type of the resource, and a comment associated with the resource. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - Contains information about the shared resource, including the name, type, and permissions of the resource, comments associated with the resource, - the maximum number of concurrent connections, the number of current connections, the local path for the resource, and a password for the current connection. - - Share information, NT, level 2, requires admin rights to work. - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The number of current connections to the resource. - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The share's password (when the server is running with share-level security). - - - Contains information about the shared resource, including the server name, name of the resource, type, and permissions, - the number of connections, and other pertinent information. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The name of a shared resource. - - - The type of share. - - - An optional comment about the shared resource. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The number of current connections to the resource. - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The share's password (when the server is running with share-level security). - - - The DNS or NetBIOS name of the remote server on which the shared resource resides. - A value of "*" indicates no configured server name. - - - Reserved; must be zero. - - - Specifies the SECURITY_DESCRIPTOR associated with this share. - - - A set of bit flags that describe the storage state of the DFS root or link target. - - - No storage state. - - - DFS_STORAGE_STATE_OFFLINE - The DFS root or link target is offline. - - Windows Server 2003: The state of a root target cannot be set to DFS_STORAGE_STATE_OFFLINE. - - - DFS_STORAGE_STATE_ONLINE - The DFS root or link target is online. - - - - DFS_STORAGE_STATE_ACTIVE - The DFS root or link target is the active target. - - - - A set of bit flags that describe the state of the DFS root or link; - the state of the DFS namespace root cannot be changed. - One flag is set, and one DFS_VOLUME_FLAVOR flag is set. - - - - No volume state. - - - DFS_VOLUME_STATE_OK - The specified DFS root or link is in the normal state. - - - - DFS_VOLUME_STATE_INCONSISTENT - The internal DFS database is inconsistent with the specified DFS root or link. - Attempts to repair the inconsistency have failed. - - - - DFS_VOLUME_STATE_OFFLINE - The specified DFS root or link is offline or unavailable. - - - - DFS_VOLUME_STATE_ONLINE - The specified DFS root or link is available. - - - - DFS_VOLUME_FLAVOR_STANDALONE - The system sets this flag if the root is associated with a stand-alone DFS namespace. - - Windows XP: This value is not supported. - - - DFS_VOLUME_FLAVOR_AD_BLOB - The system sets this flag if the root is associated with a domain-based DFS namespace. - - Windows XP: This value is not supported. - - - A set of bit flags that describe the permissions for the shared resource's on servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - No permissions. - - - ACCESS_READ - Permission to read data from a resource and, by default, to execute the resource. - - - - ACCESS_WRITE - Permission to write data to the resource. - - - - ACCESS_CREATE - Permission to create an instance of the resource (such as a file); data can be written to the resource as the resource is created. - - - - ACCESS_EXEC - Permission to execute the resource. - - - - ACCESS_DELETE - Permission to delete the resource. - - - - ACCESS_ATRIB - Permission to modify the resource's attributes, such as the date and time when a file was last modified. - - - - ACCESS_PERM - Permission to modify the permissions (read, write, create, execute, and delete) assigned to a resource for a user or application. - - - - ACCESS_ALL - Permission to read, write, create, execute, and delete resources, and to modify their attributes and permissions. - - - - Contains information about the shared resource. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - No specific resource type used. - - - SHI1005_FLAGS_DFS - The specified share is present in a DFS tree structure. This flag cannot be set with NetShareSetInfo. - - - - SHI1005_FLAGS_DFS_ROOT - The specified share is the root volume in a DFS tree structure. This flag cannot be set with NetShareSetInfo. - - - - SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS - The specified share disallows exclusive file opens, where reads to an open file are disallowed. - - - - SHI1005_FLAGS_FORCE_SHARED_DELETE - Shared files in the specified share can be forcibly deleted. - - - - SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING - Clients are allowed to cache the namespace of the specified share. - - - - SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM - The server will filter directory entries based on the access permissions that the user on the client computer has for the server on which the files reside. - Only files for which the user has read access and directories for which the user has FILE_LIST_DIRECTORY access will be returned. If the user has SeBackupPrivilege, all available information will be returned. - - This flag is supported only on servers running Windows Server 2003 with SP1 or later. - - - SHI1005_FLAGS_FORCE_LEVELII_OPLOCK - Prevents exclusive caching modes that can cause delays for highly shared read-only data. - - This flag is supported only on servers running Windows Server 2008 R2 or later. - - - SHI1005_FLAGS_ENABLE_HASH - Enables server-side functionality needed for peer caching support. - Clients on high-latency or low-bandwidth connections can use alternate methods to retrieve data from peers if available, instead of sending requests to the server. - This is only supported on shares configured for manual caching (CSC_CACHE_MANUAL_REINT). - This flag is supported only on servers running Windows Server 2008 R2 or later. - - - SHI1005_FLAGS_ENABLE_CA (0X4000) - Enables server-side functionality needed for peer caching support. Clients on high-latency or low-bandwidth connections can use alternate methods to retrieve data from peers if available, instead of sending requests to the server. This is only supported on shares configured for manual caching (CSC_CACHE_MANUAL_REINT). - Windows 7, Windows Server 2008 R2, Windows Vista, Windows Server 2008, and Windows Server 2003: This flag is not supported. - - - The type of the shared resource. - MSDN: 2.2.2.4 Share Types - http://msdn.microsoft.com/en-us/library/cc247110.aspx - - - - Disk drive. - - - Print queue. - - - Communication device. - - - Interprocess communication (IPC). - - - A cluster share. - - - A Scale-Out cluster share. - - - A DFS share in a cluster. - - - Special share reserved for interprocess communication (IPC$) or remote administration of the server (ADMIN$). - Can also refer to administrative shares such as C$, D$, E$, and so forth. - - - - A temporary share that is not persisted for creation each time the file server initializes. - - - Retriev all known - - - Provides static methods to retrieve network resource information from a local- or remote host. - - - Enumerates open resources from the local host. - open resources from the local host. - - - - - Enumerates open resources from the specified host. - open resources from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - This parameter may be . Enumerates only resources that have the value of the basepath parameter as a prefix. - (A prefix is the portion of a path that comes before a backslash.) - - - This parameter may be . The name of the user or the name of the connection; If - does not begin with two backslashes ("\\") it indicates the name of the user. If begins with two - backslashes ("\\") it indicates the name of the connection. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - >Enumerates open resources from the specified host. - open resources from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - This parameter may be . Enumerates only resources that have the value of the basepath parameter as a prefix. - (A prefix is the portion of a path that comes before a backslash.) - - - This parameter may be . The name of the user or the name of the connection; If - does not begin with two backslashes ("\\") it indicates the name of the user. If begins with two - backslashes ("\\") it indicates the name of the connection. - - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates drives from the local host. - drives from the local host. - - - - Enumerates local drives from the specified host. - drives from the specified host. - - The DNS or NetBIOS name of the remote server. refers to the local host. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates local drives from the specified host. - drives from the specified host. - - - The DNS or NetBIOS name of the remote server. refers to the local host. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates open connections from the local host. - connection information from the local host. - - - - - Enumerates open connections from the specified host. - connection information from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - The name of the Server Message Block (SMB) share. - - suppress any Exception that might be thrown as a result from a failure, - such as unavailable resources. - - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the local host. - shares from the specified host. - This method also enumerates hidden shares. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from the specified . - shares from the specified host. - This method also enumerates hidden shares. - The DNS or NetBIOS name of the specified host. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets the host and share path name for the given . - The share in the format: \\host\share. - The host and share path. For example, if is: "\\SERVER001\C$\WINDOWS\System32", - its is returned as string[0] = "SERVER001" and string[1] = "\C$\WINDOWS\System32". - If the conversion from local path to UNC path fails, is returned. - - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - The share in the format: \\host\share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - One of the options. - The share in the format: \\host\share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - The DNS or NetBIOS name of the specified host. - The name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about the Server Message Block (SMB) share as defined on the specified host. - A class, or on failure or when not available, and is . - One of the options. - A string that specifies the DNS or NetBIOS name of the specified . - A string that specifies the name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates open connections from the specified host. - connection information from the specified . - - - The DNS or NetBIOS name of the remote server. refers to the local host. - The name of the Server Message Block (SMB) share. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates Server Message Block (SMB) shares from a local or remote host. - shares from the specified host. - This method also enumerates hidden shares. - - - The DNS or NetBIOS name of the specified host. - The type of the shared resource to retrieve. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets the structure of a Server Message Block (SMB) share. - A class, or on failure or when not available, and is . - - One of the options. - A string that specifies the DNS or NetBIOS name of the specified . - A string that specifies the name of the Server Message Block (SMB) share. - to suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS Links from a DFS namespace. - of DFS namespaces. - - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Enumerates the DFS namespaces from the local host. - of DFS Root namespaces from the local host. - - - - - Enumerates the DFS namespaces from a host. - of DFS Root namespaces from a host. - - - The DNS or NetBIOS name of a host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS namespaces from the domain. - of DFS Root namespaces from the domain. - - - - - Enumerates the DFS namespaces from a domain. - of DFS Root namespaces from a domain. - - - A domain name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Gets information about a DFS root or link from the cache maintained by the DFS client. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Gets information about a DFS root or link from the cache maintained by the DFS client. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - The name of the DFS root target or link target server. - The name of the share corresponding to the DFS root target or link target. - - - Gets information about a specified DFS root or link in a DFS namespace. - A instance. - - - The Universal Naming Convention (UNC) path of a DFS root or link. - - - Enumerates the DFS namespaces from a host. - of DFS Root namespaces from a host. - - - - The DNS or NetBIOS name of a host. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Enumerates the DFS namespaces from a domain. - of DFS Root namespaces from a domain. - - - - A domain name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Retrieves information about a specified DFS root or link in a DFS namespace. - A instance. - - - - - retrieves information about a Distributed File System (DFS) root or link from the cache maintained by the - DFS client. When retrieves information about a specified Distributed File System (DFS) root or link in a - DFS namespace. - - The Universal Naming Convention (UNC) path of a DFS root or link. - - The name of the DFS root target or link target server. If is , this - parameter is always . - - - The name of the share corresponding to the DFS root target or link target. If is - , this parameter is always . - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - An instance of which provides credentials for password-based authentication schemes such as basic, - digest, NTLM, and Kerberos authentication. - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - The name of a local device to be redirected, such as "F:". When is or - string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - An instance of which provides credentials for password-based authentication schemes such as basic, - digest, NTLM, and Kerberos authentication. - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. - - A network resource to connect to, for example: \\server or \\server\share. - - - Creates a connection to a network resource. - - A network resource to connect to, for example: \\server or \\server\share. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - Creates a connection to a network resource. - A network resource to connect to, for example: \\server or \\server\share. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - - - Creates a connection to a network resource. - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - A network resource to connect to, for example: \\server or \\server\share. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - Creates a connection to a network resource. - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - A network resource to connect to, for example: \\server or \\server\share. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - successful network resource connections will be saved. - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - The name of a local device to be disconnected, such as "F:". - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - The name of a local device to be disconnected, such as "F:". - - Specifies whether the disconnection should occur if there are open files or jobs on the connection. - If this parameter is , the function fails if there are open files or jobs. - - successful removal of network resource connections will be saved. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - A network resource to disconnect from, for example: \\server or \\server\share. - - - Cancels an existing network connection. You can also call the function to remove remembered network connections that are not currently connected. - A network resource to disconnect from, for example: \\server or \\server\share. - - Specifies whether the disconnection should occur if there are open files or jobs on the connection. - If this parameter is , the function fails if there are open files or jobs. - - successful removal of network resource connections will be saved. - - - Connects to/disconnects from a network resource. The function can redirect a local device to a network resource. - If is or string.Empty, returns the last available drive letter, null otherwise. - - - The . - - - Return the host name in UNC format, for example: \\hostname. - The unc name. - - - Return the host name in UNC format, for example: \\hostname. - Name of the computer. - The unc name. - - - Structure is used to pass additional data to the Win32 function. - - - This method uses level to retieve full REMOTE_NAME_INFO structure. - A structure. - AlphaFS regards network drives created using SUBST.EXE as invalid. - - - - - The local path with drive name. - suppress any Exception that might be thrown as a result from a failure, such as unavailable resources. - - - Handle to a window that the provider of network resources can use as an owner window for dialog boxes. - - - The name of a local device to be redirected, such as "F:". When is or string.Empty, the last available drive letter will be used. Letters are assigned beginning with Z:, then Y: and so on. - - - A network resource to connect to/disconnect from, for example: \\server or \\server\share - - - A instance. Use either this or the combination of and . - - - The user name for making the connection. If is , the function uses the default user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function uses the current default password associated with the user specified by . - - - always pops-up an authentication dialog box. - - - successful network resource connections will be saved. - - - When the operating system prompts for a credential, the credential should be saved by the credential manager when true. - - - indicates that the operation concerns a drive mapping. - - - indicates that the operation needs to disconnect from the network resource, otherwise connect. - - - Used to create a temporary connection to a network resource that will be disconnected once this instance is disposed. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, using the current user credentials. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, using a user name and password. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - - The user name for making the connection. If is , the function uses the default - user name. (The user context for the process provides the default user name) - - - The password to be used for making the network connection. If is , the function - uses the current default password associated with the user specified by . - - always pops-up an authentication dialog box. - - - Creates a temporary connection to a network resource. The function can redirect a local device to a network resource, can be supplied. - The network resource to connect to. The string can be up to MAX_PATH characters in length. - An instance of which provides credentials for password-based authentication schemes such as basic, digest, NTLM, and Kerberos authentication. - always pops-up an authentication dialog box. - - - class destructor. - - - Releases all resources used by the class. - - - Returns the last available drive letter used for this connection. - A string that represents this instance. - - - The last available drive letter used for this connection. - The last available drive letter used for this connection. - - - The path originally specified by the user. - The path originally specified by the user. - - - Contains the identification number of a connection, number of open files, connection time, number of users on the connection, and the type of connection. - - - Create a OpenConnectionInfo instance. - - - Returns the full path to the share. - A string that represents this instance. - - - The local or remote Host. - - - Specifies a connection identification number. - - - The type of share. - - - Specifies the number of files currently open as a result of the connection. - - - Specifies the number of users on the connection. - - - Specifies the number of seconds that the connection has been established. - - - If the server sharing the resource is running with user-level security, the UserName member describes which user made the connection. If the server is running with share-level security, coni1_username describes which computer (computername) made the connection. - - - String that specifies either the share name of the server's shared resource or the computername of the client. The value of this member depends on which name was specified as the qualifier parameter to the NetConnectionEnum function. - - - Contains the identification number and other pertinent information about files, devices, and pipes. This class cannot be inherited. - - - Create a OpenResourceInfo instance. - - - Forces the open resource to close. - You should this method with caution because it does not write data cached on the client system to the file before closing the file. - - - Returns the full path to the share. - A string that represents this instance. - - - The local or remote Host. - - - The identification number assigned to the resource when it is opened. - - - The path of the opened resource. - - - The access permissions associated with the opening application. This member can be one or more of the following values. - - - The number of file locks on the file, device, or pipe. - - - Specifies which user (on servers that have user-level security) or which computer (on servers that have share-level security) opened the resource. - - - Contains information about Server Message Block (SMB) shares. This class cannot be inherited. - - - Creates a instance. - A host to retrieve shares from. - One of the options. - A or instance. - - - Returns the full path to the share. - A string that represents this instance. - - - The number of current connections to the resource. - - - The instance associated with this share. - - - Returns the full UNC path to the share. - - - The maximum number of concurrent connections that the shared resource can accommodate. - The number of connections is unlimited if the value specified in this member is –1. - - - The name of a shared resource. - - - The share's password (when the server is running with share-level security). - - - The local path for the shared resource. - For disks, this member is the path being shared. For print queues, this member is the name of the print queue being shared. - - - The shared resource's permissions for servers running with share-level security. - Note that Windows does not support share-level security. This member is ignored on a server running user-level security. - - - An optional comment about the shared resource. - - - Specifies the SECURITY_DESCRIPTOR associated with this share. - - - A pointer to a string that specifies the DNS or NetBIOS name of the remote server on which the shared resource resides. - A value of "*" indicates no configured server name. - - - The type of share. - - - The type of share resource. - - - The structure level for the ShareInfo instance. - - - Static class providing access to information about the operating system under which the assembly is executing. - - - A set of flags that describe the named Windows versions. - The values of the enumeration are ordered. A later released operating system version has a higher number, so comparisons between named versions are meaningful. - - - A Windows version earlier than Windows 2000. - - - Windows 2000 (Server or Professional). - - - Windows XP. - - - Windows Server 2003. - - - Windows Vista. - - - Windows Server 2008. - - - Windows 7. - - - Windows Server 2008 R2. - - - Windows 8. - - - Windows Server 2012. - - - Windows 8.1. - - - Windows Server 2012 R2 - - - Windows 10 - - - Windows Server - - - A later version of Windows than currently installed. - - - A set of flags to indicate the current processor architecture for which the operating system is targeted and running. - - - PROCESSOR_ARCHITECTURE_INTEL - The system is running a 32-bit version of Windows. - - - - PROCESSOR_ARCHITECTURE_IA64 - The system is running on a Itanium processor. - - - - PROCESSOR_ARCHITECTURE_AMD64 - The system is running a 64-bit version of Windows. - - - - PROCESSOR_ARCHITECTURE_UNKNOWN - Unknown architecture. - - - - Gets a value indicating whether the operating system is a server operating system. - if the current operating system is a server operating system; otherwise, . - - - Gets a value indicating whether the current process is running under WOW64. - if the current process is running under WOW64; otherwise, . - - - Gets the numeric version of the operating system. - The numeric version of the operating system. - - - Gets the named version of the operating system. - The named version of the operating system. - - - Gets the processor architecture for which the operating system is targeted. - The processor architecture for which the operating system is targeted. - If running under WOW64 this will return a 32-bit processor. Use to determine if this is the case. - - - Gets the version of the service pack currently installed on the operating system. - The version of the service pack currently installed on the operating system. - Only the and fields are used. - - - Determines whether the operating system is of the specified version or later. - if the operating system is of the specified or later; otherwise, . - The lowest version for which to return true. - - - Determines whether the operating system is of the specified version or later, allowing specification of a minimum service pack that must be installed on the lowest version. - if the operating system matches the specified with the specified service pack, or if the operating system is of a later version; otherwise, . - The minimum required version. - The major version of the service pack that must be installed on the minimum required version to return true. This can be 0 to indicate that no service pack is required. - - - The RtlGetVersion routine returns version information about the currently running operating system. - RtlGetVersion returns STATUS_SUCCESS. - Available starting with Windows 2000. - - - Retrieves information about the current system to an application running under WOW64. - If the function is called from a 64-bit application, it is equivalent to the GetSystemInfo function. - - This function does not return a value. - To determine whether a Win32-based application is running under WOW64, call the function. - Minimum supported client: Windows XP [desktop apps | Windows Store apps] - Minimum supported server: Windows Server 2003 [desktop apps | Windows Store apps] - - - Determines whether the specified process is running under WOW64. - - If the function succeeds, the return value is a nonzero value. - If the function fails, the return value is zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows Vista, Windows XP with SP2 [desktop apps only] - Minimum supported server: Windows Server 2008, Windows Server 2003 with SP1 [desktop apps only] - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Buffer is not large enough for the requested operation.. - - - - - Looks up a localized string similar to Cannot create directory.. - - - - - Looks up a localized string similar to Cannot determine Copy or Move action.. - - - - - Looks up a localized string similar to Destination buffer not large enough for the requested operation.. - - - - - Looks up a localized string similar to The device is not ready.. - - - - - Looks up a localized string similar to Incorrectly implemented function attempting to generate exception from successful operation. - . - - - - - Looks up a localized string similar to The specified file is hidden: [{0}]. - - - - - Looks up a localized string similar to The file or directory already exists.. - - - - - Looks up a localized string similar to The handle is closed.. - - - - - Looks up a localized string similar to The handle is invalid.. - - - - - Looks up a localized string similar to The handle is invalid. Win32Error: [{0}]. - - - - - Looks up a localized string similar to Creating hard-links on non-NTFS partitions is not supported.. - - - - - Looks up a localized string similar to Illegal characters: [{0}] in path.. - - - - - Looks up a localized string similar to An attempt to set an invalid file attribute failed.. - - - - - Looks up a localized string similar to Invalid stream name.. - - - - - Looks up a localized string similar to Invalid Subpath. - - - - - Looks up a localized string similar to Invalid transaction request.. - - - - - Looks up a localized string similar to Count cannot be negative.. - - - - - Looks up a localized string similar to Destination offset cannot be negative.. - - - - - Looks up a localized string similar to Length cannot be negative.. - - - - - Looks up a localized string similar to Lock length cannot be negative.. - - - - - Looks up a localized string similar to Offset cannot be negative.. - - - - - Looks up a localized string similar to This stream does not support seeking.. - - - - - Looks up a localized string similar to The file or directory is not a reparse point.. - - - - - Looks up a localized string similar to Argument is not a valid Volume GUID.. - - - - - Looks up a localized string similar to Path is a zero-length string or contains only white space.. - - - - - Looks up a localized string similar to Privilege name cannot be empty.. - - - - - Looks up a localized string similar to Incomplete header read.. - - - - - Looks up a localized string similar to This method requires Windows Vista or higher.. - - - - - Looks up a localized string similar to Invalid security descriptor returned from system.. - - - - - Looks up a localized string similar to Source offset and length outside the bounds of the array. - - - - - Looks up a localized string similar to The target directory is a file, not a directory: [{0}]. - - - - - Looks up a localized string similar to The target file is a directory, not a file: [{0}]. - - - - - Looks up a localized string similar to Transaction already aborted.. - - - - - Looks up a localized string similar to Transaction already committed.. - - - - - Looks up a localized string similar to Invalid transaction object.. - - - - - Looks up a localized string similar to Transaction not active.. - - - - - Looks up a localized string similar to Transaction not requested.. - - - - - Looks up a localized string similar to Transactional conflict.. - - - - - Looks up a localized string similar to Network share path should match the format: \\server\share. - - - - - Looks up a localized string similar to Backup FileStream Unlock Position must not be negative.. - - - - - Looks up a localized string similar to The given path's format is not supported: [{0}]. - - - - Represents a block of native memory of a specified size allocated using the LocalAlloc function from Kernel32.dll. - - - Creates new instance with zero IntPtr. - - - Initializes a new instance of the class allocating the specified number of bytes of unmanaged memory. - The capacity. - - - Called when object is disposed or finalized. - - - Base class for classes representing a block of unmanaged memory. - - - Initializes a new instance of the specifying the allocated capacity of the memory block. - The capacity. - - - Gets the capacity. Only valid if this instance was created using a constructor that specifies the size, - it is not correct if this handle was returned by a native method using p/invoke. - - - - Copies data from a one-dimensional, managed 8-bit unsigned integer array to the unmanaged memory pointer referenced by this instance. - The one-dimensional array to copy from. - The zero-based index into the array where Copy should start. - The number of array elements to copy. - - - Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array. - The array to copy to. - The zero-based index in the destination array where copying should start. - The number of array elements to copy. - - - Copies data from this unmanaged memory pointer to a managed 8-bit unsigned integer array. - The offset in the buffer to start copying from. - The array to copy to. - The zero-based index in the destination array where copying should start. - The number of array elements to copy. - - - Marshals data from a managed object to an unmanaged block of memory. - - - Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type. - A managed object containing the data pointed to by the ptr parameter. - - - Allocates a managed System.String and copies a specified number of characters from an unmanaged Unicode string into it. - A managed string that holds a copy of the unmanaged string if the value of the ptr parameter is not null; otherwise, this method returns null. - - - Allocates a managed System.String and copies all characters up to the first null character from an unmanaged Unicode string into it. - A managed string that holds a copy of the unmanaged string if the value of the ptr parameter is not null; otherwise, this method returns null. - - - Implements an ISO-3309 compliant 64-bit CRC hash algorithm. - - - Initializes a new instance of - - - Initializes a new instance of - The polynomial. - The seed. - - - - Initializes an implementation of the - class. - - - - When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash. - The input to compute the hash code for.. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream - object. - - - This method finalizes any partial computation and returns the correct hash value for the data - stream. - - - - Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. - - - Calculates the hash. - The seed. - The table. - The buffer. - The start. - The size. - The calculated hash. - - - Int 64 to big endian bytes. - The value. - A byte[]. - - - Initializes the table. - The polynomial. - An ulong[]. - - - Creates a table. - The polynomial. - A new array of ulong. - - - Enum containing the supported hash types. - - - CRC-32 (Cyclic Redundancy Check) - - - CRC-64 ISO-3309 compliant. - - - MD5 (Message digest) - - - RIPEMD-160 is a 160-bit cryptographic hash function. It is intended for use as a replacement for the 128-bit hash functions MD4, MD5, and RIPEMD. - - - SHA-1 (Secure Hash Algorithm) - - - SHA-256 (Secure Hash Algorithm) - - - SHA-384 (Secure Hash Algorithm) - - - SHA-512 (Secure Hash Algorithm) - - - The ObjectType (SE_OBJECT_TYPE) enumeration contains values that correspond to the types of Windows objects that support security. - The functions, such as GetSecurityInfo and SetSecurityInfo, that set and retrieve the security information of an object, use these values to indicate the type of object. - - - - Unknown object type. - - - Indicates a file or directory. The name string that identifies a file or directory object can be in one of the following formats: - A relative path, such as FileName.dat or ..\FileName - An absolute path, such as FileName.dat, C:\DirectoryName\FileName.dat, or G:\RemoteDirectoryName\FileName.dat. - A UNC name, such as \\ComputerName\ShareName\FileName.dat. - - - - Indicates a Windows service. A service object can be a local service, such as ServiceName, or a remote service, such as \\ComputerName\ServiceName. - - - Indicates a printer. A printer object can be a local printer, such as PrinterName, or a remote printer, such as \\ComputerName\PrinterName. - - - Indicates a registry key. A registry key object can be in the local registry, such as CLASSES_ROOT\SomePath or in a remote registry, such as \\ComputerName\CLASSES_ROOT\SomePath. - The names of registry keys must use the following literal strings to identify the predefined registry keys: "CLASSES_ROOT", "CURRENT_USER", "MACHINE", and "USERS". - - - - Indicates a network share. A share object can be local, such as ShareName, or remote, such as \\ComputerName\ShareName. - - - Indicates a local kernel object. The GetSecurityInfo and SetSecurityInfo functions support all types of kernel objects. - The GetNamedSecurityInfo and SetNamedSecurityInfo functions work only with the following kernel objects: semaphore, event, mutex, waitable timer, and file mapping. - - - Indicates a window station or desktop object on the local computer. You cannot use GetNamedSecurityInfo and SetNamedSecurityInfo with these objects because the names of window stations or desktops are not unique. - - - Indicates a directory service object or a property set or property of a directory service object. - The name string for a directory service object must be in X.500 form, for example: CN=SomeObject,OU=ou2,OU=ou1,DC=DomainName,DC=CompanyName,DC=com,O=internet - - - Indicates a directory service object and all of its property sets and properties. - - - Indicates a provider-defined object. - - - Indicates a WMI object. - - - Indicates an object for a registry entry under WOW64. - - - The SECURITY_DESCRIPTOR_CONTROL data type is a set of bit flags that qualify the meaning of a security descriptor or its components. - Each security descriptor has a Control member that stores the SECURITY_DESCRIPTOR_CONTROL bits. - - - - - - SE_OWNER_DEFAULTED (0x0001) - Indicates an SD with a default owner security identifier (SID). You can use this bit to find all of the objects that have default owner permissions set. - - - SE_GROUP_DEFAULTED (0x0002) - Indicates an SD with a default group SID. You can use this bit to find all of the objects that have default group permissions set. - - - SE_DACL_PRESENT (0x0004) - Indicates an SD that has a discretionary access control list (DACL). If this flag is not set, or if this flag is set and the DACL is NULL, the SD allows full access to everyone. - - - SE_DACL_DEFAULTED (0x0008) - Indicates an SD with a default DACL. For example, if an object creator does not specify a DACL, the object receives the default DACL from the access token of the creator. This flag can affect how the system treats the DACL, with respect to access control entry (ACE) inheritance. The system ignores this flag if the SE_DACL_PRESENT flag is not set. - - - SE_SACL_PRESENT (0x0010) - Indicates an SD that has a system access control list (SACL). - - - SE_SACL_DEFAULTED (0x0020) - Indicates an SD with a default SACL. For example, if an object creator does not specify an SACL, the object receives the default SACL from the access token of the creator. This flag can affect how the system treats the SACL, with respect to ACE inheritance. The system ignores this flag if the SE_SACL_PRESENT flag is not set. - - - SE_DACL_AUTO_INHERIT_REQ (0x0100) - Requests that the provider for the object protected by the SD automatically propagate the DACL to existing child objects. If the provider supports automatic inheritance, it propagates the DACL to any existing child objects, and sets the SE_DACL_AUTO_INHERITED bit in the security descriptors of the object and its child objects. - - - SE_SACL_AUTO_INHERIT_REQ (0x0200) - Requests that the provider for the object protected by the SD automatically propagate the SACL to existing child objects. If the provider supports automatic inheritance, it propagates the SACL to any existing child objects, and sets the SE_SACL_AUTO_INHERITED bit in the SDs of the object and its child objects. - - - SE_DACL_AUTO_INHERITED (0x0400) - Windows 2000 only. Indicates an SD in which the DACL is set up to support automatic propagation of inheritable ACEs to existing child objects. The system sets this bit when it performs the automatic inheritance algorithm for the object and its existing child objects. This bit is not set in SDs for Windows NT versions 4.0 and earlier, which do not support automatic propagation of inheritable ACEs. - - - SE_SACL_AUTO_INHERITED (0x0800) - Windows 2000: Indicates an SD in which the SACL is set up to support automatic propagation of inheritable ACEs to existing child objects. The system sets this bit when it performs the automatic inheritance algorithm for the object and its existing child objects. This bit is not set in SDs for Windows NT versions 4.0 and earlier, which do not support automatic propagation of inheritable ACEs. - - - SE_DACL_PROTECTED (0x1000) - Windows 2000: Prevents the DACL of the SD from being modified by inheritable ACEs. - - - SE_SACL_PROTECTED (0x2000) - Windows 2000: Prevents the SACL of the SD from being modified by inheritable ACEs. - - - SE_RM_CONTROL_VALID (0x4000) - Indicates that the resource manager control is valid. - - - SE_SELF_RELATIVE (0x8000) - Indicates an SD in self-relative format with all of the security information in a contiguous block of memory. If this flag is not set, the SD is in absolute format. For more information, see Absolute and Self-Relative Security Descriptors. - - - The SECURITY_INFORMATION data type identifies the object-related security information being set or queried. - This security information includes: - The owner of an object; - The primary group of an object; - The discretionary access control list (DACL) of an object; - The system access control list (SACL) of an object; - - - An unsigned 32-bit integer specifies portions of a SECURITY_DESCRIPTOR by means of bit flags. - Individual bit values (combinable with the bitwise OR operation) are as shown in the following table. - - - - - - - OWNER_SECURITY_INFORMATION (0x00000001) - The owner identifier of the object is being referenced. - - - GROUP_SECURITY_INFORMATION (0x00000002) - The primary group identifier of the object is being referenced. - - - DACL_SECURITY_INFORMATION (0x00000004) - The DACL of the object is being referenced. - - - SACL_SECURITY_INFORMATION (0x00000008) - The SACL of the object is being referenced. - - - LABEL_SECURITY_INFORMATION (0x00000010) - The mandatory integrity label is being referenced. The mandatory integrity label is an ACE in the SACL of the object. - Windows Server 2003 and Windows XP: This bit flag is not available. - - - ATTRIBUTE_SECURITY_INFORMATION (0x00000020) - The resource properties of the object being referenced. - The resource properties are stored in SYSTEM_RESOURCE_ATTRIBUTE_ACE types in the SACL of the security descriptor. - - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - SCOPE_SECURITY_INFORMATION (0x00000040) - The Central Access Policy (CAP) identifier applicable on the object that is being referenced. - Each CAP identifier is stored in a SYSTEM_SCOPED_POLICY_ID_ACE type in the SACL of the SD. - - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - BACKUP_SECURITY_INFORMATION (0x00010000) - All parts of the security descriptor. This is useful for backup and restore software that needs to preserve the entire security descriptor. - Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, and Windows XP: This bit flag is not available. - - - UNPROTECTED_SACL_SECURITY_INFORMATION (0x10000000) - The SACL inherits ACEs from the parent object. - - - UNPROTECTED_DACL_SECURITY_INFORMATION (0x20000000) - The DACL inherits ACEs from the parent object. - - - PROTECTED_SACL_SECURITY_INFORMATION (0x40000000) - The SACL cannot inherit ACEs. - - - PROTECTED_DACL_SECURITY_INFORMATION (0x80000000) - The DACL cannot inherit access control entries (ACEs). - - - An IntPtr wrapper which can be used as the result of a Marshal.AllocHGlobal operation. - Calls Marshal.FreeHGlobal when disposed or finalized. - - - - Creates new instance with zero IntPtr. - - - Copies data from a one-dimensional, managed 8-bit unsigned integer array to the unmanaged memory pointer referenced by this instance. - The one-dimensional array to copy from. - The zero-based index into the array where Copy should start. - The number of array elements to copy. - - - Called when object is disposed or finalized. - - - The AdjustTokenPrivileges function enables or disables privileges in the specified access token. Enabling or disabling privileges in an access token requires TOKEN_ADJUST_PRIVILEGES access. - - If the function succeeds, the return value is nonzero. - To determine whether the function adjusted all of the specified privileges, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The LookupPrivilegeDisplayName function retrieves the display name that represents a specified privilege. - - If the function succeeds, the return value is nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The LookupPrivilegeValue function retrieves the locally unique identifier (LUID) used on a specified system to locally represent the specified privilege name. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetNamedSecurityInfo function retrieves a copy of the security descriptor for an object specified by name. -   - - If the function succeeds, the return value is ERROR_SUCCESS. - If the function fails, the return value is a nonzero error code defined in WinError.h. - -   - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - The GetSecurityInfo function retrieves a copy of the security descriptor for an object specified by a handle. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The SetSecurityInfo function sets specified security information in the security descriptor of a specified object. - The caller identifies the object by a handle. - - If the function succeeds, the function returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The SetNamedSecurityInfo function sets specified security information in the security descriptor of a specified object. The caller identifies the object by name. -   - - If the function succeeds, the function returns ERROR_SUCCESS. - If the function fails, it returns a nonzero error code defined in WinError.h. - -   - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - - - The GetSecurityDescriptorDacl function retrieves a pointer to the discretionary access control list (DACL) in a specified security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorSacl function retrieves a pointer to the system access control list (SACL) in a specified security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorGroup function retrieves the primary group information from a security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorControl function retrieves a security descriptor control and revision information. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorOwner function retrieves the owner information from a security descriptor. - - If the function succeeds, the function returns nonzero. - If the function fails, it returns zero. To get extended error information, call GetLastError. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - The GetSecurityDescriptorLength function returns the length, in bytes, of a structurally valid security descriptor. The length includes the length of all associated structures. - - If the function succeeds, the function returns the length, in bytes, of the SECURITY_DESCRIPTOR structure. - If the SECURITY_DESCRIPTOR structure is not valid, the return value is undefined. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Frees the specified local memory object and invalidates its handle. - - If the function succeeds, the return value is . - If the function fails, the return value is equal to a handle to the local memory object. To get extended error information, call GetLastError. - - SetLastError is set to . - - Note The local functions have greater overhead and provide fewer features than other memory management functions. - New applications should use the heap functions unless documentation states that a local function should be used. - For more information, see Global and Local Functions. - - Minimum supported client: Windows XP [desktop apps only] - Minimum supported server: Windows Server 2003 [desktop apps only] - - - Class used to represent the SECURITY_ATTRIBUES native Win32 structure. It provides initialization function from an object. - - - Marshals an ObjectSecurity instance to unmanaged memory. - A safe handle containing the marshalled security descriptor. - The security descriptor. - - - Implements a 32-bit CRC hash algorithm compatible with Zip etc. - - Crc32 should only be used for backward compatibility with older file formats - and algorithms. It is not secure enough for new applications. - If you need to call multiple times for the same data either use the HashAlgorithm - interface or remember that the result of one Compute call needs to be ~ (XOR) before - being passed in as the seed for the next Compute call. - - - - - Initializes a new instance of Crc32. - - - - Initializes a new instance of Crc32. - The polynomial. - The seed. - - - - Initializes an implementation of the - class. - - - - When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash. - The input to compute the hash code for.. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream - object. - - - This method finalizes any partial computation and returns the correct hash value for the data - stream. - - - - Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. - - - Initializes the table. - The polynomial. - The table. - - - Calculates the hash. - The table. - The seed. - The buffer. - The start. - The size. - The calculated hash. - - - Int 32 to big endian bytes. - The second uint 3. - A byte[]. - - - Represents a privilege for an access token. The privileges available on the local machine are available as - static instances from this class. To create a representing a privilege on another system, - use the constructor specifying a system name together with one of these static instances. - - - - - Required to assign the primary token of a process. User Right: Replace a process-level token. - - - Required to generate audit-log entries. Give this privilege to secure servers. User Right: Generate security audits. - - - Required to perform backup operations. This privilege causes the system to grant all read access control to any file, regardless of the access control list (ACL) specified for the file. Any access request other than read is still evaluated with the ACL. User Right: Back up files and directories. - - - Required to receive notifications of changes to files or directories. This privilege also causes the system to skip all traversal access checks. It is enabled by default for all users. User Right: Bypass traverse checking. - - - Required to create named file mapping objects in the global namespace during Terminal Services sessions. This privilege is enabled by default for administrators, services, and the local system account. User Right: Create global objects. - Windows XP/2000: This privilege is not supported. Note that this value is supported starting with Windows Server 2003, Windows XP SP2, and Windows 2000 SP4. - - - Required to create a paging file. User Right: Create a pagefile. - - - Required to create a permanent object. User Right: Create permanent shared objects. - - - Required to create a symbolic link. User Right: Create symbolic links. - - - Required to create a primary token. User Right: Create a token object. - - - Required to debug and adjust the memory of a process owned by another account. User Right: Debug programs. - - - Required to mark user and computer accounts as trusted for delegation. User Right: Enable computer and user accounts to be trusted for delegation. - - - Required to impersonate. User Right: Impersonate a client after authentication. - Windows XP/2000: This privilege is not supported. Note that this value is supported starting with Windows Server 2003, Windows XP SP2, and Windows 2000 SP4. - - - Required to increase the base priority of a process. User Right: Increase scheduling priority. - - - Required to increase the quota assigned to a process. User Right: Adjust memory quotas for a process. - - - Required to allocate more memory for applications that run in the context of users. User Right: Increase a process working set. - - - Required to load or unload a device driver. User Right: Load and unload device drivers. - - - Required to lock physical pages in memory. User Right: Lock pages in memory. - - - Required to create a computer account. User Right: Add workstations to domain. - - - Required to enable volume management privileges. User Right: Manage the files on a volume. - - - Required to gather profiling information for a single process. User Right: Profile single process. - - - Required to modify the mandatory integrity level of an object. User Right: Modify an object label. - - - Required to shut down a system using a network request. User Right: Force shutdown from a remote system. - - - Required to perform restore operations. This privilege causes the system to grant all write access control to any file, regardless of the ACL specified for the file. Any access request other than write is still evaluated with the ACL. Additionally, this privilege enables you to set any valid user or group SID as the owner of a file. User Right: Restore files and directories. - - - Required to perform a number of security-related functions, such as controlling and viewing audit messages. This privilege identifies its holder as a security operator. User Right: Manage auditing and security log. - - - Required to shut down a local system. User Right: Shut down the system. - - - Required for a domain controller to use the LDAP directory synchronization services. This privilege enables the holder to read all objects and properties in the directory, regardless of the protection on the objects and properties. By default, it is assigned to the Administrator and LocalSystem accounts on domain controllers. User Right: Synchronize directory service data. - - - Required to modify the nonvolatile RAM of systems that use this type of memory to store configuration information. User Right: Modify firmware environment values. - - - Required to gather profiling information for the entire system. User Right: Profile system performance. - - - Required to modify the system time. User Right: Change the system time. - - - Required to take ownership of an object without being granted discretionary access. This privilege allows the owner value to be set only to those values that the holder may legitimately assign as the owner of an object. User Right: Take ownership of files or other objects. - - - This privilege identifies its holder as part of the trusted computer base. Some trusted protected subsystems are granted this privilege. User Right: Act as part of the operating system. - - - Required to adjust the time zone associated with the computer's internal clock. User Right: Change the time zone. - - - Required to access Credential Manager as a trusted caller. User Right: Access Credential Manager as a trusted caller. - - - Required to undock a laptop. User Right: Remove computer from docking station. - - - Required to read unsolicited input from a terminal device. User Right: Not applicable. - - - Create a new representing the specified privilege on the specified system. - Name of the system. - The privilege to copy the privilege name from. - - - Gets the system name identifying this privilege. - The system name identifying this privilege. - - - Retrieves the display name that represents this privilege. - The display name that represents this privilege. - - - Retrieves the locally unique identifier (LUID) used on to represent this privilege (on the system from which it originates). - the locally unique identifier (LUID) used on to represent this privilege (on the system from which it originates). - - - Indicates whether the current object is equal to another object of the same type. - An object to compare with this object. - if the current object is equal to the parameter; otherwise, . - - - Determines whether the specified is equal to the current . - The to compare with the current . - if the specified is equal to the current ; otherwise, . - - - - Serves as a hash function for a particular type. - A hash code for the current Object. - - - Returns the system name for this privilege. - This is equivalent to . - A that represents the current . - - - Initializes a new instance of the class, representing a privilege with the specified name on the local system. - The name. - - - Used to enable one or more privileges. The privileges specified will be enabled during the lifetime of the instance. Users create an instance of this object in a using statement to ensure that it is properly disposed when the elevated privileges are no longer needed. - - - Initializes a new instance of the class. - This will enable the privileges specified (unless already enabled), and ensure that they are disabled again when - the object is disposed. (Any privileges already enabled will not be disabled). - - The privilege to enable. - Additional privileges to enable. - - - Makes sure any privileges enabled by this instance are disabled. - - - Gets the enabled privileges. Note that this might not contain all privileges specified to the constructor. Only the privileges actually enabled by this instance is returned. - The enabled privileges. - - - - This object is used to enable a specific privilege for the currently running process during its lifetime. - It should be disposed as soon as the elevated privilege is no longer needed. - For more information see the documentation on AdjustTokenPrivileges on MSDN. - - - - Initializes a new instance of the class and enabling the specified privilege for the currently running process. - The name of the privilege. - - - - Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. - In this case the privilege previously enabled will be disabled. - - - - Adjusts the privilege. - the privilege will be enabled, otherwise disabled. - - - Use this to translate error codes into HRESULTs like 0x80070006 for ERROR_INVALID_HANDLE. - - - (0) The operation completed successfully. - - - (0) The operation completed successfully. - - - (1) Incorrect function. - - - (2) The system cannot find the file specified. - - - (3) The system cannot find the path specified. - - - (5) Access is denied. - - - (15) The system cannot find the drive specified. - - - (17) The system cannot move the file to a different disk drive. - - - (18) There are no more files. - - - (21) The device is not ready. - - - (25) The drive cannot locate a specific area or track on the disk. - - - (32) The process cannot access the file because it is being used by another process. - - - (33) The process cannot access the file because another process has locked a portion of the file. - - - (38) Reached the end of the file. - - - (53) The network path was not found. - - - (65) Network access is denied. - - - (67) The network name cannot be found. - - - (80) The file exists. - - - (87) The parameter is incorrect. - - - (122) The data area passed to a system call is too small. - - - (123) The filename, directory name, or volume label syntax is incorrect. - - - (143) The system cannot join or substitute a drive to or for a directory on the same drive. - - - (145) The directory is not empty. - - - (158) The segment is already unlocked. - - - (183) Cannot create a file when that file already exists. - - - (203) The system could not find the environment option that was entered. - - - (234) More data is available. - - - (267) The directory name is invalid. - - - (995) The I/O operation has been aborted because of either a thread exit or an application request. - - - (997) Overlapped I/O operation is in progress. - - - (1200) The specified device name is invalid. - - - (1208) An extended error has occurred. - - - (1222) The network is not present or not started. - - - (1235) The request was aborted. - - - (1641) The requested operation completed successfully. - The system will be restarted so the changes can take effect. - - - - (1783) The stub received bad data. - - - (3010) The requested operation is successful. - Changes will not be effective until the system is rebooted. - - - - (3011) The requested operation is successful. - Changes will not be effective until the service is restarted. - - - - (4390) The file or directory is not a reparse point. - - - (6009) The specified file is read only. - - - (6012) Recovery policy configured for this system contains invalid recovery certificate. - - - (6700) The transaction handle associated with this operation is not valid. - - - (6701) The requested operation was made in the context - of a transaction that is no longer active. - - - - (6702) The requested operation is not valid - on the Transaction object in its current state. - - - - (6703) The caller has called a response API, but the response is not expected - because the TM did not issue the corresponding request to the caller. - - - - (6704) It is too late to perform the requested operation, - since the Transaction has already been aborted. - - - - (6705) It is too late to perform the requested operation, - since the Transaction has already been committed. - - - - (6800) The function attempted to use a name - that is reserved for use by another transaction. - - - - (6805) The remote server or share does not support transacted file operations. - - - (0) The operation completed successfully. - - - (0) The operation completed successfully. - - - (2250) The network connection could not be found. - - - (2310) This shared resource does not exist. - - - (2314) There is not an open file with that identification number. - - - (0) The operation completed successfully. - - - Gets an attribute on an enum field value. - The description belonging to the enum option, as a string - One of the enum types. - - - Indicates whether a specified string is null, empty, or consists only of white-space characters. - if the parameter is null or , or if consists exclusively of white-space characters. - The string to test. - - - Converts a number of type T to string, suffixed with a unit size. - - - Calculates a percentage value. - - - - - - diff --git a/Bin/Debug/Net452/AlphaFS.dll b/Bin/Debug/Net452/AlphaFS.dll deleted file mode 100644 index f054ca64c66e077fd320bfa151cdf3d286ea95d9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 313856 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

SVBz@*GeL0q>yExZtqQa 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 H!g_-VWvffYUVTC%=G;H>pJ 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�j-G`@ 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%0AWJ;L4Np6G=+6S3==T6e`IS@M-HfbKq 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 Se!uE{e;X?EcXfEH9QZ%yWu3|Z diff --git a/Bin/Debug/Net452/AlphaFS.dll.CodeAnalysisLog.xml b/Bin/Debug/Net452/AlphaFS.dll.CodeAnalysisLog.xml deleted file mode 100644 index 0bfad95..0000000 --- a/Bin/Debug/Net452/AlphaFS.dll.CodeAnalysisLog.xml +++ /dev/null @@ -1,100 +0,0 @@ - - - - - - - - - - Sign 'AlphaFS.dll' with a strong name key. - - - - - - - - - - - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.GetCurrentProcess()' which has a LinkDemand. By making this call, 'Process.GetCurrentProcess()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.GetCurrentProcess()' which has a LinkDemand. By making this call, 'Process.GetCurrentProcess()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.Handle.get()' which has a LinkDemand. By making this call, 'Process.Handle.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle)' - 'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' calls into 'Process.Handle.get()' which has a LinkDemand. By making this call, 'Process.Handle.get()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandleCore(SafeFileHandle, FinalPathFormats)' ->'Path.GetFinalPathNameByHandle(SafeFileHandle, FinalPathFormats)' - - - - - - - 'Path.NormalizePath(string, GetFullPathOptions)' has 71 local variables, 47 of which were generated by the compiler. Refactor 'Path.NormalizePath(string, GetFullPathOptions)' so that it uses fewer than 64 local variables. - - - - - - - - - - - - - - - Assemblies should have valid strong names - Either the assembly has no strong name, an invalid one, or the strong name is valid only because of the computer configuration. The assembly should not be deployed in this state. The most common causes of this are: 1) The assembly's contents were modified after it was signed. 2) The signing process failed. 3) The assembly was delay-signed. 4) A registry key existed that allowed the check to pass (where it would not have otherwise). - Sign {0} with a strong name key. - - http://msdn.microsoft.com/library/ms182127.aspx - [none] - CriticalError - - - - Avoid excessive locals - Method implementations should not contain more than 64 local variables. In order for the run-time to enregister local variables most efficiently, there should be 64 or fewer of them. Enregistering based on flow analysis will not occur for locals in excess of 64, which may result in slower performance. - {0} has {1} local variables, {2} of which were generated by the compiler. Refactor {0} so that it uses fewer than 64 local variables. - - http://msdn.microsoft.com/library/ms182263.aspx - [none] - Warning - - - - Do not indirectly expose methods with link demands - Do not wrap a method protected by a LinkDemand with a method that does not perform a security check. A LinkDemand checks the permissions of the immediate caller rather than checking the permissions of all callers in the call stack. In this case, the permissions of the wrapper method will be checked. If the wrapper method does not, itself, check the permissions of callers higher in the call stack, malicious code might be able to execute the wrapped function even though it lacks permission to do so. - {0} calls into {1} which has a LinkDemand. By making this call, {1} is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection: {2} - - http://msdn.microsoft.com/library/ms182303.aspx - [none] - CriticalError - - - - - Category - Certainty - Collapse All - Check Id - Error - error(s) - Expand All - Help - Line - message(s) - [Location not stored in Pdb] - Project - Resolution - Rule - Rule File - Rule Description - Source - Status - Target - Warning - warning(s) - Code Analysis Report - - diff --git a/Bin/Debug/Net452/AlphaFS.dll.config b/Bin/Debug/Net452/AlphaFS.dll.config deleted file mode 100644 index ea93c85..0000000 --- a/Bin/Debug/Net452/AlphaFS.dll.config +++ /dev/null @@ -1,3 +0,0 @@ - - - diff --git a/Bin/Debug/Net452/AlphaFS.dll.lastcodeanalysissucceeded b/Bin/Debug/Net452/AlphaFS.dll.lastcodeanalysissucceeded deleted file mode 100644 index e69de29..0000000 diff --git a/Bin/Debug/Net452/AlphaFS.pdb b/Bin/Debug/Net452/AlphaFS.pdb deleted file mode 100644 index 6069f9f57e6cdf722e130055abeb41d3175ec18d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 947712 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 R^>$cuwh(LXfQw{HP7JtUofMq~3vR>kq* zHnrXq^19yjXA-}ax;i19(@5v(wWPBy<*WRne#LbCSZu#WHS>2m;V($mja9OSvf+sY z8_vRpo40@spHoNrvi`kHJ}4cvZIx9|RxMqbcCTF89n>`><7L^cQq7pRIwB?X9F5Cs z=YY#_?CUu8i#P_yINIdlIM{Juud(Bhh~v~4N9Q~ogB`~Z$HBZ~mzHBAj#W6peI3X9 zwtATNlrNWaWI54soCK=xbTTL({Xp|(==(c|X z{+Q#d-Tq&>{l5jTWB;GP8^L$Mn?PG{CsTLNWZi`e+xx(67#sN>IidHv?n}SDm-*c$ z)gfW~xSZoB=4=nk**>98+pSB(y;|rdxc$1ZuUHBSrOWu~> z9Q(tzxZ~NjEvjBNV-4H$LF5D3!8y{lBeg4=FSBDDUGs3L&WnTb0@D^%_bo?hjH6c` z4%J6-5X5kt6LD0*`|zBOijrS06zo=f**lHLFo(wxlNs=+)|%19pzH6Lpqhc+8w_R z+==bmz@5R{!Ck;R!0&Ax(%n3D8+G$=)*ZErx_Y#!tM>P? z{2t4y_SeT8Z^e@!EmPl*ZR@xV)5(SDY_`Mt-j&Lu^Oy3i6>C`EcO#w3Vp>nO1xOxd zZ5Gif;>;y5P8aZMhMevYHR<51dc zxy1VfOY?9X?Kr5{#*Skmj(FeX4~|3at0*Twlz!C@m9grF%Gla5I+m6<@^JjXambg7 zgZkt+ro=ct4AN3WxUgLC=*AAENp>nt){Y4=j(_H{;}pknDkwWfMI7Z3$2#^mo@Lw1 zkN920ssY|tS+z`Y98VoK8AzYd^fTmtFe^(ws9$jrc9?kdeNt8I zKLeZ#jtA#~Xqe-0nSR50-~#ra4_*Y?bldZAOL|PrQ#xm#!#b070xPU6)-N1{zbG=> ztx~6&eTx4%d(^HgTw0YM-B`msXWQgC{xrJ{$J92gcD!9*l80kI$APtmLv6!y#Qn>4 zc{utz4z&TP&sax-N=kzyLew(7)@py~qkmM^2FvgnyQagsYu|JR(`iDUYlgfV?i`lTt#IXe@i z{<(Cjd?&HaW>qZ+%NCE#(uNtxZRl;QU#4;o%Xp93wmz%f^kfaocsDfEzPo^`1J(Y2 zXpEzG9*(^nM|a1uH)zY}hcS-+c{t=NWruvF>^Lyu7#`y|HV?;Pj-#LBP`$Bs#C_GN zc{qkTj$<6hu@OhycTdd2F~V`2=r|~IXU8eAw9L%Iq3a^$2fo4N$LNS7?z=1VaOhe| z9MmzxF)89Gj@faU<50f$VGZkt%2FKi`)YgD=k|dyjvMlD^m8044{=nV%lgMS?##n6 z+;J#x#i6{lWm|o1Du4E19uBovrA6&k9LgWd5wGiy<>8=R8V>w};gDaq97AGhc_t5s ze7@|M>p12`94AH`tum?9D~?0ghbkBRuX&CP(C6$8$4y{Uw&ioS25)A2dvFQZ5xfK3 z1zd)2qJ5Zf1Ht>*KL~sPq|T=v1o4gLIB82g%(l)ukAic+)!+hf4Y(M59K0HQ0>p;Y zZ@|02r@)_svS$srmTkhOo(7+D`(FZ|;ncGO>G}ivcLNn(&yNr$+YNjk+{^9Pdl+6| zyC+Cob6x#Ma3I^SfkVO9L0xCR3F`Vfwug5W0m^g zhu}Z&q8xSvsdX&X=h3cayA4++ZBqSNJ$B&tP}a$;%3b;6wp`nuV19Q<-N0|10W@~K zBObcD+rJZ6t6A24*(biXtOH!Q0sQWOJqOqD=L0Di_2<=I`>}@Yb$8N3vdlP?>Ug&( zeerg3d>#(9adGqn#j$V15pS=j<>8S376@gw@)ev5j4wSC zRJ^I6eCnkj`%Jr-0@60kaoVC8hgt$oXa6$rEKu#F47?jG2W|bkopRQ=i>yhibE+T2 zVrj>yjp|05s7?*xw~p65_jfwq)|EEI8^Rja71a%8)AzyF;GU5!6C*#Qyy%^WqnG2L z^%xGUcj<|bI}Uan>QCj`K|UKh`hhJuuJX2da(K*+lk(Vcl;b!WR9c2c9MfVPlk(Vc zvg1%4ksUvbIF5{Q%yJx^36qL$2hKc911gxH7pnEp~(-mps?J=Od7IoKgJQCx0JC7YogE*81*)cidh>!iKqbh%tWJlI< zRDiOhGUB)=X2K9 zbsW!tO3Skm$Kx@MMUG>SgtWZlINk-7U+W@{l`)P7^Q5IQV@OI%6Hxil6twjtUM?@@ z;ppf%G;SphjaylcikKZ=TTnIv#Oc z6yxaaIJzWoOm-Zc*RyJqoY!4imd7|oIu4axt{sf6o3t>tp52Y(3nPwOVjMrp!*Pe> zxYKbgi#XzCdz<4(YA;VXj^BVv>yr`3oiRJsI*y`*wEV?!yaTFi8Q*vL5wGj(9Y<2R zeC;^C0j04q;#d%~W9tiRFWa^mo2NT~;%EojI(AcxV^7DSvdb-(9*$!lPgnCI4+Jj9*uGQ z!f_<|k7bVIr=Ze$SHy8|jANbSC?ZU5p00HqPlLO1{I?Ou^)ZgdSzES6gvsT2-*J54 zIMzoTm&7=_KV`sGWpRAEM?WQo#Wu+k>(nEdvHhgw*|#% zu3f<$*w!`0j-ak3+JjbWFZ%TduyPf|(vq>d<~(t%W1q9loQl-_PXC=oR(}Tjnb&6) z@wemGA@E7JAJ_rx5AF;e4t4?ug7O&(zZW=&?e5@UP*)X0z(c{Kz$3w%< zkiKtf1UMEv5v1>z8VSw>Pivf-qidb9Y~KP-1ebuNjZ;6S|Bzb1_U_RIr8xBnyXcWi$QJ`euO?f*CU0^8eUxQ7Y00AB&O178Cce@;%3Fn)=TBAhXTDCQVY=cA)ro0-LgZFvxddvVB3m*OEO1 z+#1AZr}+Lvb_mG#7_vu!JAg-nyh}ej6zl|^1d8tzuru4If?dF|U{`QD$h&*9^Ff8X z804M06|aK4b2j@LxDWVekoV$csqUuTHfMCCIddVJGv1^51zPMl(O}y5P}ZARmzaH; zOVOOG+UBWUSr25@J>NO->;T@ysxc?EY|pVbar>F=mfW>%1%E3>a`b!qRM%ktuI%q@ zw%et4bExs9L9BbT9?w`oN7iE<4s|#KWK@Tx1EZnsQk{ahT;;KJWQK^ws@mbVcrH6S zUc^XWNAnav_qMTHiw!q8`rW~eVRYo{haFs8%@*m%sBK5|I-0L3N<%X=bT>>~MWm#} z{O(Lzx-!G1D_6dq8AIDuqc$v^$y3D4$4$kq0<9Nq$Ld0=M#Gx^>XB-EYeI`HJf*V=2jCLGjzzo~t zz+D`w1!%hysCK0DP6^wLC7SW}p5O$wRqHfHqVtf(7qG{K*ZD`|45|&K;3#k^cse)@ zJOiX8vpO%H1?qfM2A&I+gZ4bDxe`B4T}$1)P9x+jw#rrIJa)Y2INk?k#|II|d9nO>+;Oxb%xKoIY}09*rx{S? z)(EtAjEQkP?>IUpaD-zl>ZetYv0NPE_{4FvPvGF5hbh~AL7gG?i|m*Y<7hJ9*3%?A z204zwpzIhDaa<7N=;Sz(>^RkNi~?l`{j;pikCGV2L3!+8UZY71eKljp%!uQP7{`fu z>#l7wDlv-@ll?%(C0NA^m$Ew>>P1SkLAa=c{uiV92z%Lo@(64+7ahy zyTG=Wr2L?7ZR|J#R9Xf^9C2T`TON*+9mhz=@xxj;_H!Ib^<%o@ps#MyG9%)sisi@P zJREZ!$2`X|zZQ;BdD3#dm5_awg$z~9JFbP zb3EZV)V~_d8v39vj-xB6e%S62NBn&Ij^jx3>pdLDKA`+*&xoTeR>!{1W5+P2kPok;iiEazoXA?aF*Mz{<`+h0X437iQB%`9lzb-o#2NY zU*>Ry+y8*ueiZzO8%hi{?7PsLv_hT>jEJR1H5ZiIR-ObFGC3eZhOpe$T#KM zLESKImAa8_$?>5P$KkQG{5}uI4;{xTj^osb!8Fy1$T{9~?3qi$LYaB@st_-oW;GIBswpH#&}+B94=y{8$Wk zC&!`dXW7x5wTe~C{f>h+V%qc1K>44CK(*_K!F|D>gZqJxfW5#+LF$E>W4C8*6WOIWXE?h$@_RaKZS{61j#by&XJZ`aIS%=|T#i22B)4`D zsIhSDbvDND1zhPkLTkLFLD~h~tSE$ILwW@tNcJ8>syFJmPpV z#&LO`{P@;!P;4eYG@fDWX?)(zPxGW@JL0IGwgQzFUI^tl?u*&+OUI#n&#fPw9S3tf zO`oGn#PM*%v5a^xIgTS7M+@*qRxO7*j>ACtmBYct;1QtuXv_o6_5d}$u@9*6jh^6< z;QpZcBlwThQEVRuGG8>?AJp6vn@ETm+w(ItP^93f~)?#kTC9 z4a)v=LHYgjK&9gXa3HAgM}il!Jshk`rz)nn{bzym*k1{1Zp&OyV@BgxJUB4bE-97)|TzB*{5e=I=kb#ucG@Whq7;5R<$(6)Bf97_i_7oHv9EQ zw$T<%KWz*dr}9_-XcnvLrOHmrfv)XQX4#f(>zrlNH6+GyRvwNM9mh$IL+2gKad3=7 z1z4LM*p($)&GRL)e=6OQ`(pMUzzFJuZ{s_~^0V1xHa}%gmNhKbz1XF6bO)6_RGeOX zeph?Pp|oXLLk`smai~rxKYtK$Ope*HM;<%EevIrG5^==mh#i>6juFld)ic?ldS>(P z^q3uk9EZv!%NnMo*l|!MrW`2~$MHmrFvUh9nZnjlk_k%ib zKL{3qI=&l7e3RaXzysKR7{q7kI-p`GsP=j)sPN;#HEi2-sa49(!7hEuo!s;(ZKs+2 zJ{_;Jb&gAiymOYd73;ICTApB+((xOx5x5pq`AJ`O^J%t~o@c=JZoj-T@w2;vzXx}B z`@awVf$hD)=Rtq|r@fi}+#%o}*?%~QKXK{O+?)aIQCjrdms|K-_wD_D{jPqezyOS2 z?b1hCnDli3`zTQ?e`1$@%3mpc@>h+)KZ8n_(zyfpHrw9=*MVK!e$~(S*jBpU2Yb8y z_z`noOX>KK{YQZxfk%TIK+YG2SLOH#+bYM;K-J@afaic;f%CzCfwYCx*WeYP?70ct z$hO+szd>96T}Zd;@O1X73@7tjmMGtJ-jsEE_T@0M+Vkp>W?w5jOiP}!Xvup~T5>1Y zKI^`XIo2Fc>g!5h_Kd&0`kc0aZRJ@{6Vl#`S6-4YS=9~l#o0DG#xXMw$G*f7$9|5Z zSHv+q#!;1r<6y^uy~Ymem9r!MJo1%!I0iY6!H#1{#BoYw$1?1^&2e1FZ{hr=a>%|#kPFp>EJHlXs|0-43hrTSWs<3WsU8racrw?QcsMJn*iD}w`FSkTB}SO zXwE(K<~*0ArDaOXihm&ZH2b+PZ0@gfJtSXR$@PgjJ{gn`Ed`$k zx!y2+uu6BF>j~pS=YyodypM)7WEZpj8hAMi|TAS6z$8)fBfYUyA*WRF?3)O)qXS82&WQUfPJWVG5XMLczj}m3E_URccS~ZK+ zm<9F-wg+RUo)e7oTFy>Uo9|1EXRowvNI9~YRc$572kN{*N?aaRKg%wTck^(NQ>Gp6 z4~pY}h$H??{nvRoj&K|U9LKs7@$98ndd*waBN?w9NdQRv^BlQnhep#C02WxL3@ks~n%o=vvlI zt8c|Ij=S@4^maDYtZyS?9KXuLp?aotsh+9M($cc_92LL+@md}Z)iZIZo{3{b#1X&$ z@tNaLeap>{+Ur}q?R=YuV}`S%3{;&hkL-v)SHCS4!e8I#+7Vv&h@&dvh_{_x@^Dah zOnzMM?6@N07#fv}>RWfmq538}!uqCjo$~Z{#G9E{Ztf?{axB4~P7j zIH*I$j_V?h>UYYhzJ2L9RNt1chV|_M$MGPj`t~zd-&RFjOQ~Vo-LBi8!jqWK?Hga2%cZotq!>YsypkwOzrP z5l4L9;unrXI=LKSee1~a>iQOMf32xhD%&Iu_48$i`uXCxF|s2**KZ%ku}^{>s%PR@ z3GNM2-&~%)94nX89mmcI98Wrqr@#&zUmJ16>&NUo9O_%k4)v|Yp}w^(+jC=fT;({F z@40!p!Et;7>bmgLh+|fa<3Y!v_Ls}ilyQ35u@$I(MKjRa@pO#iUB{t(&*k8n#Bl5k z?!Z#_{isPk-SH%#KNpqf-Kh=GBTr^J?WAIz}AxVjK(eaCCPZ znrABx&9k+3#OJo%?KnCo*zp6$aWGiK@xBp9d=B^T97mELJI-+o166;Hk2t2r(y}2B z$2iAP;yA`f9E)Nc+i((5*(UkI3mnIVpnM?@#<=`=GsbbS<49`zJcDP-1 zUbZLa;kd(b-03)$MI7=DQDD5yHNI^u}8xhoyVz6l(EbQ~{(I+wl@ zaXc5xk0%^QQrrK?aq!HbX}3Hx=<+mP$NrLs<6Fl;N6&Diqd9-^XJY>2IFia`N8+fx zv~M|949&s zo`*CXdS2bO+ju`{dLE859mizHQ5tc?%jJ?h92Yu{tmCMNIO64Um*Yt4(_QU2t^t+j zKaM!!er#t=(-fezV_k)JO{l4SapWkXP;dRJw9LJN5Qk5#VXV~rqJ{xhJ z&2>oia|iSvQ#;>i>&n^u7N4%ggjzJ;R`refwsTb9-eX(oTMvp~^I_$KJ_gSKHIH>P z_$gQn{uP{{ZN^$BgP*a@I78}lkbZdTOVFlK&!PG`FSD`XR<`~9@GgX`Ip?J>`!093 zZ_Do$tl>4(?zleL&NAQmOLD!&2ZpX499*E#}8s0_vGO?#Bm(z zI1Y%7gNV%Eo z-qB!Nwsmc#^P9?SH*hT5T=$u|fsAjN`!UD5%(c4_KXZ*Y5#)1FQGn)6QFkmH&>b{yh3RJUYDb=`_zkKUWd zj<9aYj_SGWe0WEahw>l<50)ZhA?Yb!}=kgqqKAbTZ5`E z){aRrj^iE2c7$2O8gj_zh+{ucK3Vm}a>VZ;jLu`n!H$FaZ0tBB;usaPqb!ddw0UF4 zU{H3bzF0fr_aQ3t*l~j67!E2wR9`Gd^|?rG?&>^toaQ)A2W5xqi{*&l%UGJn4*Zcx z%Op^CsJ>W^u_@u_?2{c2=dq*Qam)l|hw6*vsJZ8ezgTNLX`$3eJvtxEVoQLCN$1&1z{4nB(_uZdx9O|Ft z+9Cg{a#0#&=j@21y1%=U{VzC<@s2}bm$7Q0e_%MS2h|V05mbHV6k)E9mM{*lc6BG) zJwW1_xhCpcaK1HjBk+-Cu7ldF_LC+v*P#S_fbh0$Pv%@Um30>DIM$O{ZM$sAyF;4G z5|);P3ENnoCAN(z{jaiy<)A);(%&6an)Z&g;$u>SmRJsj$>li6ai|Pcmh$)3-nc&- z?l_X{P}`CnYFpAcD&mOW+bVV(Np{p;A5Mzp$J9J_kl)4*%Gua4A+lpyjN|+~c9c1e za!~mpA8qraB;vT1igJo3Z0`J{}UI`8WuLjj$R$V;<6z^E@2DYbzxOCG`z7@oN^V|w;#LVlt0KA?3 z^FYO02;RXqwwO9hy*K-pfOoO~9&kB$zuW&akbUO+Q}=?a*}jjq@d~Iqu6p$#_!{^S z_%^r-Tn|cb1Nd{cKLLpwn_K@2ws|hY%cJfp$ivt0~65AuA1*;2`iD z@ECWTF-0>6@)Ypj>^~L!4>$_^7CZw?GnP9V%zzU>@lFOCv0Vl>24{jzz*+A29Iz?d zwypH0l;z9x4ydl~x8_2flxocvO6;}QN{%1TI>j7s#T)80Pt{&?_2n9CFV>^nG0l^z zGQZow(Z=~rJ0IyV<{xQprk#IebTvB6UIF|(A?Yo?q_&g;dM7X ztXi|T=Nk0r$*^dySM~g@gUvphrmHyC-)whaW{9`XUUO>xn6*Xou(VJ4sU#$6RN}e5M2J%YM~+)#SzO-yggj z?Bn*UwB(-;0j~n(pRWN2yW=N;^3%oOP2f1UeBefipl%GyYos_=IL3EgYq`lX=M>d z+>R$5hrDJkN0sAHJ?+Brc@amvzxQz-4%K1hhw834u8cV1eYIA%+j2>=;}*xU#Btmj zam4M|KM#lc5VC_lgt22q#1S9=IwcQ>`Vr#zh2!{T#1X$vz0h&&PT1T$ea3M-3o5PZ zJJ>cCx8rulkyKCLbR2Jis$+kSIO6xHpUcDXk>mK-anN6KcI4dG&BLMdzVbuoecADK z#1Xe+cN~qzu9DKCc@N^)8Wacfu$>+8>$2nXaI|wA^x+H#eK^NaeO=ZU?(-c-QhVv@ zIQ~EO&IUfqs{a4?bvt1q=#Yt^6UT#siim)SiaKE6zyTAcqM|a`4V#W_ZNos(ZeS|v zR8mqZQZh7DQdCk>Qu2p|MMXu$uSl1oQPD3lDk`-9`*R+y`?|-?EiU&X`nPzaW&6-UofZ6&WL)j8RTT z>RyWUJ;e`OkulN9U~ZaJI$v7>8O_?tno9aFcrE@_jBRw5=IT@Mi*kUI`_hYDzrS8W_e@EC0t;k?L zZqo6%lkpYU+BAJX@K>$Kc+SaKi zjEzpl_ni#Z4lXb0?|{1A$;i}Re(7Ye-Z1UuSD}pbbll@)WU6ET<7E61Rz2Mr%1Gan zc&-&0A2}HxI~o59Wu)&>ZEi(I2X~$O7+C4xJ;Kf&>FM};D>Aw{8K*cI`Js$iY30)G zseQLO-3Oww)%(_zj?{bl)9=k5;bdfLFPAtO1+Z*B47T+&Jsp)!#sI=>2hsT$YcrFM z>tM}GuMcHBnUYntb!-n;fx-*Qu(jB*p#uH)KqJb}LxJOl0t zSHfzuTIZb(>s}Dmw<@>{o(VHgj#b0|1=qk^VBW87-W{QMf587K{C|bzKY}!f*&8u@ zoa0=_-5vLI+z+lJzAZ1UHnne}y^@)ryYr7=-{kY)F|ZVTlQ0Q$E+?iG@7qc4hn&`Y z>#miy?Ar5tCy4ejjMJtLF}9d%`s^^cG^Jk`c&HT_=Q|nNOFkO;tdX6J3)9N~u~uY^ zb~45|8JC4J#;3`6rWF~JoQ$iTjB7#}!$TRfN#Dy(20D#Bvf(NqH`B?ehTGs*nH~k# z;Ln9W1+#x*-cNjyJ6{CXbKI6?9zK=jV9M)Bm|YiKv^=z-s`*|=jx%>pD~~gfL)Fk6 z-CU388_G?$L&sKRP@9Yl_AZPJt;ucL(y!h2XhjBjGcqoAGA;>aq|bi`wju+&7#S+t zW66`s)}|wUZ@;h=855k0iB5*r^;Smub&4xmkuk-|D04EjuD3GA#l*gyOm9U-rIT@^ zlW|ihBmJI>Pq!kY&dE?+kv$qh8R>JRg{{cA&B?gk$@oktBmH{f=Ub6+my@y3$+$a| zkt*9IRKlm74Ax+#p5~M0CRI+{qfW+Sa69~JCmrBr_`AT5!zaUEfz{vZyyij6@vHBB z0;XP?tS7k&~fhPH}7%i0e_q0z2NV_w(blh zw%WPAS$z($?cVNj(*xmh*!}9jnQT=pUF;kfp6l}bHhdl|pa1-Alr z&u~_jb|59Ir}0PY>yOw>Q9p8w0+6eo}x(+%bL zA6k*2wolSb+n0<~zdkB09sg`aMzmj-j8wm#dj4%G$B%l>+T&(^%O0}$BK^iyxpd5g z)%H}r$HCS3RZpp7$v!Y`b0KLo&+enwgqsYjomIf|V8WPZ`E5P85})dU-sz0v{$oFuJfv~qwtS_i(nAB=fc}VHqy6235n~# zbLr80=P0AtHkU5)p?9@WM`E!lK&~fpITVwfj)EyK^E{;VtIs(dKVi(+*%t=Re*Mrh zh9lCcZ=Cc^t9!?-vh^m1^Xyrrm5ItiI#m|Oz`aA6>DN1Yv?3!~CX&%Vl#zbjWk4%3 zqHR$!Qf)DHy+dtrcq=j}8wlRan?$sG84 zcmRAuDC=eHyE>Gocy~H^N_Tz>`>M<&?+my-d}b&oy`Ng#iVV$jBxA6XL0xqDO7Ev0 zZ$(DbHcCgzHtGG;s#au_xO6annY>I0(~;_@n7_ncb27-YvB#0H>@KIdiSjZH&V|ci z^-rqf)OT|)t;$UA_0@G&x#*a%-N{zF?bE{6YA=#4o2&nk&29Oo_b-2IMaDT!24!w! zFbX;uss2S}-iBdKV^gMds2@=}REL!g!aEtM``{$w_*P`7d?Z7Cj$~XK%1F)iC8Jj> zGR8X@DmTfvJd}}|YwzLsKqrGbZfx2K-U;N&oD7v)8~iFajXNqY)pwPjY>RCw(3=!uT`IGup*Yj796!gU$xBQ-2J9gc!)FZ&X>RZ&ce+J+o;@zrXUaR%9T{ z$iN0hhU%AQsiWe4rQd?X~((Px19{l z5oC{OA4xeF8P_=(>Kj!?Q(&7Xy|d!?X=&>Af^9FVGhDw&v#;!`G|8^AuiCGbGc-*` zUnfKLt)+};AE`1-^^xiA_QFGCC8cpoKl6^-Xv+x&3e%Ck7Q4&IP@8X=j!T@3 z0=OgRhlMiIZTbZ#CP_L0vR?xjK|ll~zCg%gNAO zsbyZ&Z>f%{zmm<>U)egAe(mm;PKNB>Qbw(l@hMn&tqWzOm+c>&j7&D2>tx&p%ci%7 zGScf<{KZszDQZzadO8`sV6~T1Lm4B}?2+SSsJ*n5(a*`Ck2ZB({gbsv`gLfcqZ`NUo3L3JOkcIRz=Vl?2Omc3eS59 z9v^6V3Ke-71JW9>32X=IfV+VHpa@I>bHQS;7HkH4KrRENpaffZmq*a~)o z9LlgSC7r)U7-)2o!-SpaC?2Wnc~12)2PN>SG=l3Q9o(XaXz2daw=b0eRHpL7)^=fhMpV ztO1+AHn0ceQSS$VQcwjnsa^tBg7shv*a@;|CwX8fCkAd9xx2NZzGpaCofE5Syv4P?=7^T1G03g&{vU@h1T_JCa4`cO~`YQaLV z9IORfz)sM%k6?MPJqz6oM+y2v&mipc(82x%7X1K@pe&=7PmwE!Yh9 zfZS2!8}*hJs0;7Bqq7U;}6dSw+|v6o5%!E?5j!gNkOzuEIcNk+!CJ5x>;mnJ z?RZiISAZl~0#<OFDL+$Kow{NOTa3y9&80WLH0G&AutFOfhnK?G=XJc4cG{_f!!eITG9fBf)Y>x z=7Pmw1y~1~!EVrHGUWqGKm}L`mVtF(3)l^Et|JU60u?|Xyjlj3@89oz-+JttOA?Bc91=V@&*N95||AZfmL7wXa>7MP8qU5A(#wi zgGFEs*aUWioT;Q66oGOu7c2p*z(%kQXv3uoC;*c{5-b7hz!sndO&2f(lz=MG2$q30 zU^CbOvJ<2m6oSbh36_AhU^Cbaa;B3WPz0uc*w184?&K<+Hk z07}7Juo$cbo53#7{$|nu3PCxT3s!)2Uw3)l&AZbb$t0#iT|ECK7m zR**fHb^!{(WS|EXmVmWjGuQ)iZ=-#I5-=Mq0&Bn~papyvPz0ucCa@f=2V21&koy_( z049M(uoSEVTfk0`og@ul2q*y+U?Err)`2Zx7id3^yn-T71scIBumS7>?dMarpcs^c zxnMC^2{wW4p#1{s7#IplK^15OOTlWe5o`n5jid<_g2^BWmVmWjGuQ#L?w~$_L0}T7 z1&hH-un}wnS$7f!6oSd15&Um*StMq7?2L{|Q&wP8W<2(1tT;Q?Ci^Vy^y7wJnrJAg ztEo-YHB=_*N7U3ME}nYB4Fh$mbL@zYlC=RSzK_!`)~n+c6X(=7Bxc6CrGEDtQBzfw znAT8PQ(fQh(nNKlu5w!Jn8^9j;=%@$?5k}%60w!va&Ua`-DHT!^N)r>H3W85uK~i`9i3ZdR|ypd2?c1+04YKn!0ffHpB9&#-G#whI5E}F!}ar*y++Bn|Swi z((sLF8m_FVnl&?V>8#4~42c*pScy28H2Au1%QfKM6zh~EU)Nu!%R8NC(|lN49szA- z@34O+Y!P<@_^{TFLCo7XDwlh1xbE343~Tcnn7Sd!(Xgi2#UmmYVUi=%$myUU3C3m>=0Ef8)0eO=vN9Z~VZk+C*e->~%~=GwoX>un{R!us z*_sy^+qWSJ{N~xqw0@`$;pF_-t>3HB|8`WrnZq!3m|51K^M|T?uAMe?UfykLoXW+!msCGrarIL+A6-8oQC2=j=MPoy0GHn;r#CuRdl|i5qI&Hx zb;vsXIFs!vW3+tNptDz0=Y*P?hQi7^)=@QevcCe-O;-J4RoIu)m>WCP*!#L z>b0+1dot*L1>M)}rF&xKEr+3Q`8>})($=V`ywt?sOk( zlVJX?MfbyAx8@WrbRWpPU;T*sF0Zd#9USg>OXlx43G;;4r*>3WS$~u1vPM@=XW#B{ z)vacyJ8I|G(EUo9Zok5`jp|T!`~8h_H|gsg$@lB%{(e;V==yMdo0`TQdj5T1vc;w0 z#7G*}k%nFAX}F?#+M(<8ZK@>OD$~AM)!4IH#XMjU^Eve z8X6LHhg`3`?%7A%3|||`_jk};*@|w>Syz(gKEzc#ANI6ZzG)V(*=KymvggIzF#AbIJIESL2O0$M5)g{LcI0cRd?l_;&p6`;;cF`L+N%rw`2hUg=TV zH|hs&9P2oBV{Flyb!rK$u}k+ZtIb`GpS7#`ZkhU89X|su<@gx*O86>x5==K|&QFK0 z#{VgJGQ0qu0zV8BCix;<4!7m*SbIO%0FLN+j|*4__j14W9rPji`#FCTzjY7vh2Wxa ztz5)eJ5LXEubgq3b_{jDYtf^kAT3E%^Ey}>s0jG=P1){1&+;B^?4@{i-ksV@JAz~V zf!r-lo>-Mld<=Ka=kONQK|EI^n@fhBKWCP4hm#?e46&6lm=*PqP)3#+N9_BH2^Nc{ z<8w}iSmh+PGA2+~rJ)QvuTAaAMP)qdWQb)Ov6XQ$`xK{yGJ3gmbW$R4Q5jD-8Dix{ zY-L7=VF=j^$RCYtbB^IB^mX@z(CqsNH=fqaV zBYbP^^I;vbbE1GJ6|9Taq2D+eV(pEIt&9@-p9!H1JI6^~&xy+TgOedv|0T|p7dv0c zY>!<|hFJCxTN!GV=ZERAbB};)TGmC=5ilmGzlp;+Fz*_mpVK?i)1P0qbBWCDQtx$= z487M$<;=6LPR0pgzo$ON&J6 z2reCGhUu8iaXbD7W-P{Q_93hE1IOh?lMddYkUS6nIq(p809*_Yg2%$=!i+_+!7yWo zo{4a}mYVw9fv4G0--<{*dsNK+g&kXim>+Y`CVqk2*BF5u*+K7!(jmPgN^MHx7<;g> zV*Kjc)@sE zx8N_q>tSRke+DmuZGBgNWLvxcHgRX3-Z9l{?qd z&)HEpk9j~>o<8iVCqZy|%qI2@+sB-<-()_MFlQ0wL~x3csXo%zC;QvZDQNSi{%$(Q zMA!Rq%}arE?`FOSNR5gHi7LRc3&)(4~BrrpaCoatH4I^ANT*41=O$k>wo1g z>qkXQP|LNgEJ4 z(733MdUU*T7<6d9sq3y%rn{&raPPs_b~o*%oyvh2}*{wYe2tcT~tPI z7nfeoJa2zG+@9V}@uM=V-Gb1bQ5lSzCN8~fQab1Ykzv8ySr8M#lL@ z#wlSseE-_MgUv%ew2i)MH^{l4{u2xZC7=S#1^;pTX92Z;zh5`h)#>(;sNZiBYcqA5 z+b1k4s~NisQpYuLJJyb-oiL*8?xDs+n3=Re4L9ZVyB5pf%lI@<94*+U_0E|87n)ZVx*n07tR+itb9ovWfI{132QwYS~q`jWDS3SF^D zlymk#_BvGt`_jA6%~=yhqy6(k!r!_Ny(%-!)il>t93M`{bx+bzj+b)0(ZxTJ{V`?j z?a2OERib)^?q^oNF6@^r5u!Tc@?z{7ZyzMT5I;Ab{ATAsa=b0gVv(@)PodjHo|;p6 zx{~@)?k>3V}V!^y&nDM&!ye;wh4Z(ur zf(0iB3vP%nNXGBz9ba&i(c$;#S1J)W>UiijW7ny_adr)_vX$2G)6^N&wGuMR{a7ZR z53A!%953QHx7Wv3IvKJXRWtT(#Mb4yZIfe)vz$1E#F>tNbtI0OLo|-cheIaL7UC2T z=Op|eMB;EbElzpj=5ZQKe0%kL%_p^665OJm9-(@wzNpQVU`mkuxXrx6U|u1|{51n^ zEi>zE>F|Bz`fLK=-m_%>{uKKT+wSbk^%o5`#jdZGJywygD&i@Q59jME$4tGIAYb=% zPHiB1&iDP2w;g#E$h(j*OPpTSKh@=EoM`=<@JaT`(2jc{FQ^KVjnuy6@_6#2VBWO& zyt(oDN5tn}+gbOdrq&mO++=wIalHE(cIow7XBV#TURgiwV8)D$7a33tb$wxy~)(RO0u2l2~z-#<^sKYc{dJ{NAQfdF#<4uIWSFHCvtU+2XvJ|Jdqm z@?vfoTxu>;=SFbzZM%2tw$@#STbnPU5G2vIa_$vD|TEwTWnTl3gGoq$; zjKpjoN=Vx+W7xecoCZNBXo+ z9WAq{KIKummJx3-;U@l%)ulXM+#+7s=H1-_zU&l#EAdAYew~Z2vKihYzDet7J9+Rn zZWrwTJ%?_*KVmC#gPh=+pgu@03X)F;^KJ{~Ee+;Z1@pfY%zr&t`JMQJ=Yl(qkKg%+ zVDTU0_sodjvoW~$()hiz;!QR2reDPGD+})L9l!tH`2F4D4}2}Ys5buDHSq^W#2E8-I3F{JCE;QrLRu=O|ls(FccFL&x~v=7c}m@`+K~ zs%IpkOI}mochRU96Ibzk*n?T~w)QO3eyyp{p9`{F>ea`$TqpXxPSWB47tQN`Yh3hs z)jcu(R>Fh0mr-`xm+l5PD&23BVE+Ds@aMFmTWw}CY3@Z_#q(ixdI-q$>rZV!+BdtG9(rmwGf6?ENj*a_~ zj?%ia>iV*2W@AI;ql=un!9abakFP#bazBWaPdS~WY;hoKU7rV4=U}{M%~pn=7Z2?u zE$R0*{)&9G-Rasi^*q|34`d(4>t+ZD@5lCfOVto@_gON3-$rlVKJ>~?1*CNkP#hml z^-+;odbpawoZZdg{TwiQ&d&iQZ#J@agE7P}bb4iX&Do-Hrd3#*$@T{_ANTdT7xIGS zvLN|iW(Q?hFs}m@J3eo1ES}W3A-Ucz8=YOE_4^&{@>IkwqbjTHgEquHT;4d zmdxK~^uDwYy|UjX(%M8k#qr^Md9b|MXL&@=Mav@_Sqs5H2do9be7yJwR*f(N3P)fX0U3M#_+`$Jpjj`k(lv zL4)sq{9fAzmp7)wp?ii1A8OtAds;N?Qx>%)6EL^l4euF&LyDT-(rQp1T>l^g@Q>`#9zq z{$W+M6=hY4n(E5>epgji4;;`hd=$TjuH%fYoK{y;Uo*YIpDml7u#)SQp6FaTItPwC z2gZGwsptG7$MqSQ)ujQQBm(9)$WwV{KxqLs$=0Mtu%DZJ6d_TOjn@WTGbyQiM`z_(G|D-hN z%@2fE``JZ4vXLVhKAvwsEXO-~xl`RnmY=6b&rN6i*V8#^ktF9 zd>a1OB5_#;rs*S{rUOu%e01r-UB>y?doGUpj+_>8MojEA^x`2m+)!0Bt*olPzuBvk z(W3cK-@_qu?zk4`WILUc&Qf&l0cYXAV^=DV42Nm*{2sZ_qv!iSY3{*7$?sjedUZrG zvV%*4#xcR&1CC5Ch$nZ(=M83|(|AL?@rmHh5y4%f<9Dry-}Q0)?q$KfwefqOJ>}l_ zgQi%}^k%&2pKb0tHx>Zowv7e3@X0}N@B8;X5Zw1<+}PhgUs0tS?{Lw+?03}FT`r%o z5j8WXR#u0$ScdI;5l7*Dn0@s-|E~6*X+7@8s@dI5c4E38&%57~pWrX9Z+7`{P0f^V zE&0hJp5pj$YA=fahe%tSR>nq~doPNg`$W%cKVEfT?JRoSw^7xl73f-=Z|+K;-t9m~wM&1DHS4HZ zRc4sh`2*?yeOlWSuch9K9#&ga?;p@R_ur(~&ri2!(EC5=y(fd-=-$Gi=G*J9=(%^k z|A_u2|7QJuFRu1ftN%UPv3EPs|6~UJ(e__Ox_7hqRy-e8ZBjB=>KWE=jTgntF#T8? zJ!jjveRkHgF=P%w=IO-S>GW%y;?iE4%xSvyVOV*2rLNkSRfS{Y3gYh~KDWKaX8z5# zH>F8ykG=KkJ~ewSC3>zd(J-s7+Fz-(VbsQ>VWwB2HPQ%__MzzA3C0t)*KVs@dDa*i zjjQWHTI6sz9M{$6>khol>wVO*pz*1ov6+jJXE4wuxAR0*Fz>GTeA@Wej=bae;Etz) zJ3a{R86RIbKfdrS#=ZExcLq&Y#P9uOyy+h4_4RO-@LVJ-ypSUhDQVuLsf}%7%jyP@^{j5`6s325UyEdvdxvQ-WHv?clrE-^jv=c>4})>kn6B-*I9jSx~{Qg z{{EA6-SkQ6ima=P$=iA$89rWT#x@CK$s3OK{u;_bl(D%7GC0xR13AIjwC`Caxw_vh zbbCnqo1c{SNEt`xEZNv%E08=d!{>u#aaulfoM}WXdc0v~E!Pt4S|xhCK2y7kq(O?Tb<4k5!32id~v=tc2DTi4I*f4}AHp7zgzc}FqDPCnI{j#T}XPjl`-tD#gKtaC?_<|}=g zQ+6_mR+^hh@7e)84?r9r&aXGwjtSFT<5mTV(}nPB0N43rcR1O8-zXZ#??K82M-n!A zZWeV?>p1lx(c@;1w9ww*tGo#Za{b!bDaMj97ToyrQ;02IfEi>^QR_u9t3`sBlTjUtOQ zw(KkY+HjG}d$g}?OWt2@k@rz`H8Y0{oLIrr1I7#o(x1qdE%p1gfd58ORDU+%-)vof zbV_$XeOsoq`1Z5-TnvSa_A^J3mY+n@G9mK(!=c*1>uo>S>W$i<9eUr5=rxufGVrk2 z-miTYWzc&xdUs~ldsuDm$Lg%}Y~D|{Wd61%4Ile7jIIxx-l5vt&rQ}lo$p6JKJhuUpbBQ>R%3I|HRkJJmLlm?x26?8H^+1^A<2QozIma z$@6V?!w{SB6_(83V@QAOU+L+O)S0lq-$45365qsi;eCJqw@4oR{-VxlIEkL~*ATSN zr|S#RbKD{}tE?)u&!=>cI)FVmX9x3+>Y!7QYzmTV;&;3gpVz~#VSE`DpKmk2){^;q zEH+pXu|cG*n*8tA-VT}7{)tP6e?KUNk*nd>l!I?S`c{=3+pwX_Ar0j*_bj!)53M{= zZY`qbYira&)aA72*}NTAU0_uo9j1UnBn_J*X_&w@(wdq6RunsaZ6@s%#8o^W_E5(x zmGyqv7@eBOXk3z09cno~`26*~&;$veOP23A^7l?8f2E0;wW-`4*tHYcs-%lfcy;u{UM zKD{chgGjU8Q|M&dqkrbV*F`p|@2D`HJDxP>2jP1K%!|d9*2$!EJ5X4Eet+v;YinZV z=V0Djt|Tk&hpOvg2! zxfXvH_&S)&zWUbtyi#`_S+O#XPll($gfZ`7c zW0T9_jy(I$l+^o(rf|G@o5rQod!m$H>6WAKH1_-y9L+}^e)SOz@Tu@D*xK2qqXX|$ zYZohsd7CdHOj`zK>8a$mob1qOelg||U*&c?+!dBx^5DZ0l7sS4k&89=v@%C7R4aOUP4mpzze7bgW)ILuegwN(4$1zM|-2KQ^x*mW#!%COZ zM}Csr-Vl2bmbDkdny!5grYvKRz}LeHuaqpouX)Gk;py)9jqn%n-wiK?HReACKjY3n z2QS0F2L3W^^HqRP>zZ8haRn#_cL7<+=T{}7^1h333pv-z_&dagh51&d?DMjLd3II- zl%ED=7DpOPzE{H0a{n5Bl{;xm(zZ&Sa(@N>v^#z) z{3`w?_%#?C8^(4)@}#--5k;euV!!_;t~;Z*m>1bbS|AdVUK34*##<-@~>Z55OlIcgLn3WBGjNM6Q$T zqdL%=<}gFg;RfT=)GOk;a^<=c?_=v3v-MkHIMt1 zp!^u8P{y$EAKg#-g5(kSm1foXKjA+X{xjSW-UWAo{|YPh3U@C2H~eb*)I;-*w7()kk;5PWFKe4tj^(UtH(>23-Kb1_3-aylp5AM3^${q8`y`M5bow%*&78h3^g&prKl?{!PcV!WdzskWtZx&pok|CR8?u*&liSmjv&Plt!WGhl_U zf=A+?36FwrhV{-mU+#;Q){4c=e@ESM)zXdDa z_u=XIH^X{|o!X#|)4pRj;io<8Ubf_i?)YEfYWyF;pMpDJK!xuJ*Wo`7W{gO7amP=D zXW>`hdo$eE9q$i+8b3CR&4$(2Djqg6d>JgcfH&`514oD>79D_;McqJcyFEw z{|Kyi=q-Ui2Y=5U{~`P^{$Ij`Np6J+ll&F@Mfe?fDg0~rQFuEn{X5{t@c#i`2JeKw z4DW#-hd+Xs!&+QD0UrTB3G+q%UEAUu&Eqn#6a96|M#6J~Y2Ty~)1y6_9!?R(9`waXh{v^BsehB_9 z%tmbtTP0V)3bz{Gi2qgi2k>j~CiqQv{w?@N_`eJP1pdA|{zLeu_%U!2>v_#2>cIt30w$&1y=f=hN&yb*PQF>Y#t@M!qma!Y3}$La4!CH;1l3s z?)XT!3;t2?iEyzyJ`O$!{|(MR4bH=VBdl<>j&F14=fT}Lz5qT2z7y^N-v#%C?}L@T z&%(X%FM&^kzX11!zX4@xCnm_ zm^PUl<&KYm$Kk&W9uJRm$4lVL@m~&4fNyZer@<5Pm&2v-jWBIHsrS-Mg6m+~c(NWY zfp3MS|1zH(SeO=it?aVyBGdmedS0~oFayE@-)<&G+#;-hR&7H$sG{-ywa4#?roa*>mCvyn?LD=UQX1N9Cn4gE)W2c*A(qWJHC%m)r*VyHHwt@@LFG}OjX}bGx2O)v&SXd>*+*! zxdZFLc4n8#r+ElrmK#|)CO^uj-t~Q=IcD>v*`u9D=eRm=^AW9EJxNm@ zX;XbsI?gn4a?D-Bs(L{P)&OR%&b&LB=gzBUOu(NHv)(fMFsw+DXSwsLoy^b8+D!6P3t5jP&v$%*W6jZZ zUMtY6Ie!OC3ryY#UkBd{Uk}?glU4@4Y)4}cTjy>2JDqZ|?MZcA?vB` z#HuKJ)q&2TZDe2ju7S+{N>ct5lUlDO%buw1K(R4qBU+I1Z)>=;GmkY1NuU_I=SS|87_%wIE z5BxlSl@RNt_iGXP>VR%(M2gyX?0I$Td3|zlL>A_K~c2@gECsgO78^Rd3$MuNwaw zSoYoy%ifBo7VEI&+}Gy6ztkBVOnQ_YOs{{&n6p2bo1 znW~qcWM4b}JepEJ*F%TZ3orLb&S6v{}ipY~bs zz&sbOyhQ8gRZhkvINC2~p7A}JsBh22(wXnk9 z0Ba9rrt_=aPsguzUIBmB9j8BwvHxK9rEh}iOU(BHY`w7MWb3C|gzBpHlOF~u$BTil zw@QKLF4H(>f7`I>*R1UG-`1w;^P*)-YcOR?y)iaDJ8UOo)5^s@+nia(g-!Y-zvAu@yj9;;5>LD+!L0)d&8yp`@rNr zsrsYi1u!$Cr1}T?WYaHS17GXTPlspVuXldNxL5`L+ns+tT#5gFxEB5*Oj(*ewK|wF zMDMapu7x!|eiNn*CpW^7C{b1@$ z@*H=3JbV{^>Tc{_SbJ9wz;*B<_;y(F?{M4%Q`eIB!4JZZzz@Of|CllLCHP_dZ@`N8 z7W@c)_GJufuSmyP7aMNy1qcy|`FcO?+j@jc{mrMdP!BAk&b!NOhTO$tc6z0ucsTF<0F;{bGjkSeo z?ZiH>Y}-i};zipU{fTL7v})5%sK3resq4dQu$_HAI55u&OU4kelH+oNoeWZ#)_)Pk z%wsNqI}`3gSaE3+ru~TX@vB_buc?iycVX_5q|KY-1K~^XYd$j!rcIjTCGc?kv_+Ln zcnzWqetAK2!OZ-=kM|6BMfc$YiA8=i#!$iU9m+rX3Y zGk%)+y5^SB*B_=&PY#94V8$J-Fq4cs+IdKhhRfkGu+mfFn6bpfp90g@m_26oH?}?G zptx2^A3*Bn=U)ptz>5JtbX2T%ZPyiQ0{ zc*(kulIxEgIo-=}Ea&WRwZ*7xY9p=_HQvfRkKd=8W1UT#u*bdJ!PKC9Gh30|o@s5s zKKmS)mY9!(Xd8&u-}anSy|s2JPLpAuW6mr?Wr}G{nM#Jr(#jZ`Cc{3HoLL5S)5xfY zC8HsfF)>YseXcmOjQgDo^~I8*zSyQCwZ7UF_s{!s4Ut6W6OOhQ+s<*huQ?gCg|znk z9DbFE>Y++$75)J*ZN;odb(}V0)*+Hdn@Os6==d1;>-cGNW<5gNFzb)&;a53MosBVO znfo3Tz6$?q__2w(ZjMc2>+wGc>-^L3oA^mX?A!43@LTXV;P1k(!yDo6z~6^Az(0Tq zW7ZHqhJVCm73RR^dh}7SB+|o!(f0ZQ{vn*F?I$mRY5U0ncn9NBIs7O5)i8ZQ@)lU>(D?Zm{GWmU3Txcd@z274 z!_W1Y*xzBUmzZm^YutIRhnQ=#8{s{i|33UL_$TgsGaN9#vvuMmte|$!NQtxe)SP2} z+cvM#^5fz)oG%0#r+S&=ooL5udmYRhU=_c_wC{GNA32}jethjg80|031+=zMrtM#B z+dhl7eHP~>PvfZ7tv*HjiT3y;cmybn$e{Pebz;{?eN&Fx4NA%CVa_YRAM$Gju+KvW z>i1*$K<#8Hkjuh0n8;jzZUf8aN5S;R$#yXFqi`*FCjM;vXT!{wlFHf9utsX?QL+F& z7FJHQUW(e>+Sh8ed!D_W?R2kE>f4gYkJ)FZ1M^IEKC*HFWow+)RZ6ecRoSr8do+9! z{?5+d70$!2w%ZMs)fG-9P5m`{2HoLd?zpT=eKu=~UhtLf_%-mU_$%Sl;aTqZ9QX|U zcfr(qa}Uf}u+1-{KhBq##)Ed|&AvLO?;kQsne)T>UF3cz_^s3^%&GiNUl%5*_#Rv z(xLb*WsGz(M!}@T%ss4(8EG=?bI5@i^;*gp?_`wFPv{($a_P7!O@@7b*v{`-%9!e8 zXl@{Tl!r1dNRwfo|II9;*2%yYMh1PdOGj!gC41QCb~DRJIvMkvjQOFA)c%=d*k^4s z%ec?UxZlZmAe50Br;CtbpKlFxU!p0OELgJT9&<95!D`QsV_U{*^UY9OKH3+|4Q;c9 zbM`sYAogp1%f2~)vBkJmPTuoQ-ivTg&ZvE<+%*QOy}bnYhhKr!?lk79|IwItEv)d& z>&%#U6TFV&RgRy9b)NAv_6F&F8~!%uQ|XlkwH56j=^iA_qizJf%<&vrfsVCj2Uo5g zE5m3#e)6BTJsrn6r7_x``l3he=`2|JMw8P!I!%Us*3y2DvZV~>0!GHgPR1pnjG{Cd z_L)gLuW2b`jFWL0tp2(d6Pr9>?;#Wjbzj zGAN^D2hLMQPDVjmI_xuw_B*UCW!&au-0oz2CX|uh7P9u(a>*+A~gP6lltZJzfP{CS*z0`3N@?sbQs#D50-6g&)m8n$)tWPGZB zw=kDK-Tl^mSgHLQtwZcHe}Q@aPiZ+36mncn?La?YgR^1jRDbn4e$~rw!P2rGmIj?a z8-5eNWT`z+N6hhY@OSX5UB3mF!QX=^J9EAo-iTl0*AHOqZ{~!H+<9yn`!VedU9q2Y z{ueMv>blP_Va*BOVOx;>L(To>4Ts<7_yqU^*xFkm2_O^WLyucAE6{%Ued=y`&?RPdsI3Z)F&fDeSt0W^zqO> zR~DEnBrWsuX(wYgd=lwk4&`K|+Aq!DJ^K}?ei@r~f_DPBg-*uZa2xz;6Gy@K;LnAd z;M3f3>Vd9Fnd@N>z!$sYs%g}F({|`f=GVF7H^UEe{8o4gj1D6o8D@X&8Td;aXS~zw ze?INN^e5I1%8}~6=CZaf+dW{7d^)ags?++ zzs5aF8UlVj2OkY<9PS9e0Qj`u7}^kPZ^lJDX-tfKOg=cyZ~Me zV;^%~{lfS0(=VES!{+r?(t9ST=BUP2jlCBFt#vLm$FzRY@pfi3QJAa3`nrM;_Bpa3 zwwB+@pX%jOAV)uA^4APU%lOy$RmShZePQ1pZo_{G{tw_ncl=WLH~357-^OBhG6yl& zp!P1S37k>+Xm3ASR_WJ;%43>+2j*EcrC0rRl_KK)fgY8|KVkJlO4kYS$M{t%wDvp| z*1AbOq}EHaoYqS=JtyN+8TSCipc2%E_8Q7L`wW@Arc;1F+TZnZ`q5$90(HR29h4@+ zKGT(1201r*Abm#0z)(i|T*E$_m089`P6qAF$e>JII#Tx$6p?oO{8V7>fKXntfbu9e z%E_Soh-Kr;GS3113ce1%#>y%1W$-k3K0F9qFur&xdJ`$y!)_<5%HZ;I>=^Y0H?{mfpTCJECoAS8aK+rY%=HtY39QW7$%m z-?xFs!DHYFa1VGE%m??m-;ctNYrjQfNUV=4Ca&T{%MW(7{B{@1JseL^MaC`dZ21Sr zTkh=mdKneRy>PL`_p?6+Hh^tl59mV2+aDBzas zWijam#h@HCf#qN$*amVwhaOM>CV>Xf1Xh4`U@O=Kx;%^=PztI*6Ic#5fM$^O2>Av@ zU8)v~ zFyD_;-VWrwkuIH#<&=H3UX^0))U`*^>GD6ls0*ZC6)#zMann^F(`jLMK&U zbPZV7G8D&$>*mt@i%6QM^R8R}t}NwAMG-w;&8zCY%nIb~1W$0_YfiV~a40QK1!++n z*+Dpv_YQblbRj-VgxT7qYzh6W5FH*Ye6Ajw``h@o=QMtH=VCL|$v2=L5 zE_6Cxi|BZkFzWh87TIcje>+~A*?u_a!=7rS5rtuk)dQ+)Mmbw}tM5 zDO+EkRy%#sI{gaza=kv4ZMr^FqYh`C?xRg4T(nNVN*Zc?8ure!NyEY9+n4cjr!!i{ zYti|P*Xi?pRb6F6!ggGTtBiA9g^rf-H_`pN*X{Eg(S0y^^<})o>5G=}Yv}u-*SA+* zZKrWK%eZ}qz03G@(s1T`E$VfcXPbtD$+s`#VyDw}+a>|uLg#d^Q~55etgo#qo0I;| z9Q%IQCKumzeGyBiGjHu}k$=}IMDzb$;^+JL(w`x|pHr8+_&ux{&EM}4zmJdK&%CDTpyt$G#|EcE zYbozGqGL=-hf#7cZTCY24h42EA_(^}j^J2-r;KsJEbR%G%;(reu-(T_UB{6OyUq`| zGt#=Kj4@6|F{~n^jXD{rXWyzgZr9~OxSm(NngZmmaxx~tUGZz*JrBMbe^2;Y_zd_u zwzpQmQ}Nq$4#B5A{}b6u)-~HJV>+(9Zvl2)9fa$0nR_FUt42lu*TAYHwXo7(4=Y>) zd@_79+#6P!l!i~^*Z4XI9_5Z>1GC>tI@#g1*PU*I**-MyQF;ze@_#ivAGT@Ny+QUF z+z#BC;qT+l;hIzGnyT(QD*z+GD9|;`pUTCqr33CVvo2aLccVx7yN7GM%12YEH<2d8 zu8V_ko)neAHmZ@a7*=;geq7pngfbR!+^%s0cU4T+h&Tr1C@&-9DL5bhGqCI^d!7Za z#6K8*7CsNgR_6NND!3H?^Y9h$3$V4@?a1%W5tX~1Z`L&{U3;!DzkT`3K6d>ZgzMsH z-d;hT?DHzD@?RUuKPAlDQjXj8ZJ=xW#%a2vJj;F8$@rd$YxAVMQ^%5>;2*$e!#{?H z!<*qT@K50h@Xx6Z^Wa~?--Ow+ad{ksPx-ruJiQC91-dt;7ts5r&J5G2_F&h-srR?E z=a|wiw+ETZ=SQ&8F1xENKgO^6{xA3>IL0-s9wJz6j&)S{{APdr+}myPpnC{Q@ar0w zwY^%0(rTX{$e}IT`yEd+$MxV-i(r)l_rRNS;2wCB@3FAjiONmo zFb==!68EH-cNkp`?|(Vidt8-gm4jXD+UHd9rj^4L$W^_$5*`TitW5F(SkHM`eaXGb z!LDQNeN+UEMa$t9Cr_NiIq@;EW9fG;V7)RlEC;(L&HPTmg-(W8?M!TCk2)D*)d#VaF`jF3mxuMiuKhCChnJj;m*HrA z;9h7W^Bb`0!z-}b<*TsT@!_2FCaHSino{?`XR%adxCcAc2HK71Rwst@0R zRUbCMst<34`u465b`6-h9Nu>F#3~1|Ez7}-$A+|u*=E#3mh$nzdD(JgH;Z@VU@$*VU@!kI9d)L;a55Q3syNW89#t>xIC>K>{>2! zIb=>w^hk|6dVX8?-=9h-?fYol(YsJ={jTDeU9<6?MH2#>!BgDt;mB2bN5I+e zNced8QdsjV^}k9d*T<8Zb&iH@I`Yvo82It-rckF+XxD3j(Sm6HYu8+v&C7>281S`Ng&`_H+&8#K)Kpd3FCf+TyEIXqsH>bt&yo86 z_JMxiTl%$H*bX{_^IiH*`1?ezCD-z~5DwAy4&b^k;We+8ZREtdCZ{=E{HnIM z9(8MQtK|861sE5N8)?b>r3tjT#@kK%d^Pn6olx3`5`HaEcppZ`YdOYT$lParql??w zUH?8klBWjZ`TQKn-rJW+lk%Z4t4;f$y=3@(-ljMQaix~bUz%x~$9x{_eq-6xsziAS zHs!O^Gr07~i1P{8rzjBCRYs@NA6~D?;+xO1>5)OKe{hAp4yitHosJp3fvI138Rg8q zo%*T%)QqoZz{lY~6INf^7d{p42Xii5Z=a2yV=?gncU<*HevNDN)k&>UHQtSL$7P3e zINp}0_S^Eruw94i-DBN36JzYlrJhNe%Cr}CLnAfMTXA=uUyo})#+Gkj%39}@-;Mf# zy8!u^M%ONqGQU{)R5}z+e$81}@0mTKi($-Sp08Fa3h?)Whr!DCaQHO15T?FJr?G?N zoQq#_ImfPwUvqaPk0Usu=kd-mW4N7L*mruhe7|i!GpcD0VfUM~4z=}zX9SFt^z}~( zdXzu$1jlx+I-9+uTf#AH&F5@n<+YUlxdQ0L7E8b?uo?Wv{d+8+zRmYzx|c?-(y@N` z$&R(TxR-V=aAWxj=(xn}27dZ6U-iI;Ynj2PCTTxb(sHv{3?{`&Y^}qrB^a+Og zIrV&DfVlsTaiX<%|F^uqEb8Z5c=RW!v1ni4$BTwJ(0kG{eXpq>I)~}PQGRJ_*6J6% zw)D#W^tISG7pPq2)YoUx2baTIlk^6>TXCQK9OqBw{Jxme#$7_W{~35@Tsb0NXYzvh zr1*j@@y45D@y1u;^K0XG-N#{#H6OyP9iUHtr(Q(whe(>V1}N+a`%B;&ZbM|lve z(58~^=KbEdc2tW$u4MxcYxop!&GxA`ik`y{Uz zz7O4B*q3g5TgJiY&uH^Lssy-bnct88uSfN#iu$nWUFP(5x9ZK`2hjWNmU<^v-oiL^ z*!1eX*m4@vy<3Fd-=yi~o;EjWIEZr2Xy-5k^}A#|UUuDhtRygX5T z81(u)?{a#(*{qwti_tqSU2ocbFNd0EuiM}68@2c6&|Q_Tdt~*rx;eEC#@vT&Z?D_m z|EsmTcMqfczI5GVYi3n9l+;vKHxTGh^X>1iDsO8wM)Um$x|gNv9zT70Rb@4e_;Bgn z>hwnI*b?-9D_!q|L|OUx>Z&=1tk>Imk|tQVXnsGB-nU!otu3poPgrXoYM#CB%}#f; zoWFqXf2Hf5IA`Y6nySia#g)}J9kzUz9A)zz9Us4l?&E$H=}*${Q9T&l8OO&>PWMSR z3Fhxobf30w-DZS5Ty`&Rw|CyZg#KYI^@sOO9#lQgnD>oNcQo&hqWg+{>b8@E!SRE=V3!!Ci5ctzKp(m zy*`bZ6B4PGU0OCnK@XR$XFL6_Ycr{M9Q|L7>Nop9qbjS*3(FeH?A$%Hmy7SZ2^0S- z#DCVum%TE?_xo0TJD4bGWxbsEFZuWf`K(^1`M&lrihy17r0x&Y6lthUhOWjYWefIV zlgd+XSo^ts%<;?I+C2SzhjyKklBX$Ve;{`b@dC%HQ}Ww=)FG_DFEINm(rwoonPr^s zWQZk0oax>JyKcyQ|H3dQLwp=E#8$?+tl{i+Po=}o{{wattc&Jlw38w3%4xBcp}UGo z!o1iyeCE7d?qrCS7qOLbHa4@@mX!`WAJ2Rr=+#b!_!Pp5t&9YFMl-^6*tvD)dvm5b z8De#JVk^Vm8RP4UohRG(iV!Rott-r5P1!QVFz+4EepMb}XrRc{eSUfupM5W%lYOm7&@DA zI_$hJb2=V#GQ>)U*vgPKZVYAEIb3F&e$~kk%cf#0LlSNZW!U*x=5##gWQdgxv6V5C zdwXj_8FpTk*&Z)D8DiN(Y-J4RN>E`a!_JQ~_XDpx8DjMVVk<*;G1>bVR8Q?ZCv!jW z9VbJqen4zx=x(wJVLI$wC38A{=wyhM4zZPyem|9+b7W4(&z%gh(jm4oQunnfFLvIL zxgThDGQ{c!#8$?si~+sFyx8&IzAK4fv1mR0wUZ&%H9)cUUb}Dy`1Q1Z-(KvP9~%R<3!1@hkhhZiTEHYw z3l@PDU?bQDvbflg2Zn-DFdHlatH1`Z9q7jIF5rKI(^%y9e>b`Woe@dc`Fy9lW462g z*W&(V9{S0+=HFfq41<|;LE^c-t?uEo1?&E4cIx;=3pUbXuadlsccSDIg#>Wlyj%E9* zYzE{00nNiz9{bvZ_V=Mg^L!EEr$lwLcUD$CEx~OZY4+k?MB}1)zL>Z(d|c(ZMO;7s zu61#vdM_bvjgPB5Ppp|$H!Wdw`gkic=qw=K%|4!VM&fxJZ_l7_81ZiR@uaUXQQuI> zUVnz?r2M{dG_S*ne}|7Ry{*KrP^XKF=63|~@AL7czqF>ItZGzERe7S0Ihe_}PyY%R zKdQfw_=|mf>CX_~?_F)npnoLsm-_fA{krU)R?hiq@VKb%QN;a)hA5cXrrd zn~(43*U=a6``qWcUhhBG|LdIl%%!z$E1p-<9_#Vib`;M$lC*w&ZM%u*m9&0*Z99qQ zEzIJz?INC6(h9GeGfkI?JVzSzV_s1J#)Ii#K3E3UfX!eB=)uCFKNthb!CbHytO6Ur zcF=J-&(nbdPz>t8BCrB%09!%FuhZ^80T>VJz<-bbw<3^>xo-ZqO-=9Vxloo0+8s?t zB>hq_q_S!TB7F9X&yv<%_wWBVb-ve}=LF8(+4E1#3&bDkJ4MPNlKE0(kJ|Y=!8jGY zCvq+R4$JblIs2p%ug3JPSAC30;lbbTYB!~o^yTY3$=6qozI$6(pPQGgRDDt>+%Xk> zFZuf1@6VZk?rvP2-hMhC^7ZofIoiG3%6i>A&W~>;djHYNdh@h$Gp7j;o*i#@_!(Y1 zZNWIZ_A+1f`fh#4u3&7tiYd58p^i}O?!+B&FRrXKOH@B7aZBl*A zVZ);qeb2S9KG#mhwXka7rQ!DFbePIqizBi(`^MKZA zC(hs1s<&5Is?5dEdul7`b?v2J`-bH^1HEINUU`0-BrVlG7su%1H_q**x3E4J*Y0~a z^zUZ$J?iUgh59=`MsFQ@ztu{5U3s!7HHY6`Z$a;`e7!ALo>ejWZbjdYR?@dg_4)n6 zZRk7fOl_YnTwe?KvGMf#0~Xxv2DPw0S6|nvKEM2CqHm(FuNCTRen;!4AJm{kf=Ix+%-P9jj zx9n&0xO7JbdHYM=Lhn)58naz04~LAbl55A1CY6<@IJ3nWCKRrmtaLTkl~qZCA*Cgg zu46OuaMFm$zP^&F)5>`;+O#e5{Oe^raw&^HxhB(==r!9=<+qA5)ce;aO|3TT z#d7>!w6FPXT9D$09OBF2!HN4{g3o)Tg;C!6D^^}yC407R&s5f$lDC+cy-BJWnpgak z?!(t*-f%mrva(iaAdocD1pPE+HKTcZ@MV?d(=zW6UW{E6;Ah$%eBkl(RU~gs^`sFs zmsU&?dM+9M&RJ=SYic8DWDiu}{MZcXVK_hS3pNH4&jYhKCfAgd3BTkiCH*GQl{~j< zp5w{WEh|q&$&KEQwODBDjngmkfu^jV(Id^+tz(P%oa&t_Oz{^1=A4|CyRwlXK@GId{#-nb$uxuP8O|#hiQ2&bc?0bKjxu?pv1P|M?H+ zJg_k5fsccn1;^wpn2__(bG$hD;lpwsdBw!WJ;zjTT7mujD{9SgJMHP9vvoWeB2R+K z1KswA1Q$=dmY)^t`>-j9UgST7TrR!8ACbM!;QuCz2M(_nW&Dn_(cdWS#@<8ZnQG_j z))-&!z}J&^;%jr}ZW6ofdqqxv`2i-p_?$WBlKz4=(!VuE|DEVBYGwWB2ln?G)4N!| zrM|f1F7)4+tlt~0n>UY+D+^~!u54Iw__o}QE%$#8w#-*s{CY7DTb}7fCUF~J@8V#`KnO98i3YfFYst*V_ddfLQdeMe=P{6=2-@jQIl z1SG%9?jNbdvyC*-wm$^%jP~N-Z??qbA+IJUnTTkq#Ab0@1U3aQC(lxQC zzmxYe;6$#D^)BYlhIuhIJctcPwV@5254PU><-PzLPH96M7N`v}$8*O+*f6*aY#65X zVZ9Cty-lUFRy>Rim+aIAyXcUsM1-Z%$r4>e~k`pXvMUt z;pAL+H^EyDuT+=LgKWDHUfC}3^Sb%0n~Pqtv%1Lw#;==lKcx?xsac<->U-z(%1J+* zlm1c8ta&-JD{|^f+tt63s(&MA&fjxx|H$-NZvVu+8_6%fM~K}FwN=}&>7O^?$4VZ| zl(g=;-#<6?epYk(@!ff+fW&fF`gK{KNnRJDar(TSPKUV4^K-=L&a4ePa*H>(QWtG{Z z%D(3QbdmgmT6}T1wHafx^z$+{7m7KvPqqW|tdDc*kIAWDo0_wC&YaOXw-0G|`{SwG zAJ4ht=A60PQ+LnLx%>O6`_D|>KZo6-oO|BSxvwtg{=eotaB#;dyLyesHeV1M^;klCU1gb&1ge;GB#(ICA;NG3l*Z%#O zA(i}Xt;%w@R@=#(KZm+QO#J6#27~ChH?01 z|7FsrhBRLGEv36YM)$MmKA;VB%Y&=gelJD$QEi~RE=KoP(A~ccbblJ7`#E$EZ3Er4 z`T&n#*PciBWo@8)Ta4~y=$_IBy32bvtZQFI_w+WG;F*bY?8xCkg8;VbC7>Ad! z;ixvWVM~k+yz{qR|2DLtyl=xeyn+ow+t7w>F*bY)8!l@@8){Foaq#;E{^mrxDQ#%O zr)q=WHdkT8j5f5Pu3y9Y@EvTps|{_Cms-f-$Kh3Mc)Sg5s8<{O`tTYyENep>+Mm)e z4y&=@)i$(Yp4#BY;k(%I<2JOR^Qkrtz74Nq!*ANqh6QRv7i)_7_j}mzNgLSU_QIB& zZk7L%wYxjkU_-m1@ng5Y7q$@lyOLk>y7aQgBs`aTO--J>GS7zbz3e5iwG_GT-xm@y z{Jgx;nLmM9TjHKLl6yycWTh$RHA`~6u)1V&*>tNTH#<#9#T0p}O6-$+&%Tao9_bpX z*Tp{Bm-DZem(|qrmD&5*h|gnA3xWqZKX{mpk>rtmH9rq8A}YZYyNB1G=e)>M!+B3H z508aK@<<${ix589Z}a)&nlu}?k0$$2VoPV@-;aQPRe6sgZdqHZcg@bZ`zNV;p3b@FgPi-0$+_>RIS*cubJuViQ`a844nPTq z#K0Zjr#);^KLfc-SyD}nblZaF5eyU0rNm?%zd4Y+E`4+M1+$;SXzY2h8|2;Iqf3ga zC+WkCd1Lg=w<9j@>wn)TZ)(k?%Ifm6iGA`e<9Fgb_jq>yzWwCCK6yi?mDf(IE;+lR zWLj-?QF))d!f6wEJKhB)GsaY2S5k5I#52w)I&IQvr=NW0sr^g(4LEbx_W-56W$(ke zcrVa+cXq)>zCpaV?V@=EN#(r|+dGn9^1AfW zb|u?oUjJ9APn=5K-vztP^OC8~RB`gVxUEyW{d&3mO=pKU*x zzgyO>e;et~{|k1aU;3{?Y+nN;uS?%nn%Ow!w<20!cOdNsdCF5 zXjBHi{&ncTt&Q~8t9~AZ2#>eX|3n+<&*ix;Ieh&;LjNnRtlvFvGf(yV?e@p$-;ku= z+c4SPdf@Dk=e^|c``z`}v89de*r0a!?f56y@o5w7koMdijs-wCT)x(B&n}MR2bnNN z<_qs&f7cNS<3}r$=VrCTFVCN1NAEVaV@bY^hdyRvPBvi2fF{}@<+%l4is2Csm#?kL zvk&*YS8rUJfBdOVy`Ceqc<@Byly?*=tC3@d)Wxd7hMabdDoxeBJ z?oW;AmG-+5TYHgD^0;)Z-F{u1-cx)1@_7$?JDi{0AGd7zjA6e-4!?YUjo!msS#K`u zb~*g=c^|!f8__G}GY(tV0LkOhwN?4lsl9&x`T_Qy--x}t+n>66u{}obCiIrIvfgsm zv2ytR=WozEx0Us7j?w!edY^73z3yIMDf2ct{Py=-^u8Le*P977@Apn|YkFtHR<*%z zi<`0Goi?;#DgC1ye!Ki1Z1}JVHb@)Yh7YB1NPd^6wcDtRUmt9g!!N^+u>Idnuzh#i ztFvLb+TfSr@37&33u626R;fqj=#s;q%WlDjBb#7@l;H||=tEk`@A9-&8E#YC{eJfM z*gmKUwzpIn){Zpci_E3}fDKo-p$(s^4SxUoF*e-NhBnk)Xyf4b1zWLUVH?=s)~QP_ zvNrf_`j6PKBGv}GojjChKWB`nm|V$?3#rd({1^|9aJYQU+23yJZ(N$X4=($myYjo~ zxcz7sr#=@qjMJZp)7mD+sX1*&;-9@Q?d(_)W5=IK|6Uv0F|e>4+u5E0`h8R0O!H!;SY{&Rf4dbyLJNmbg z9i#MjjN8->zkmB1b`&(pj>z<(S!?#VHtcMwAKkF+{2iOdeU3JDAJfpLe_&Jj=V;Ti z7@I!Dru64%Q$9Dq|9t-7NF_I%t-d!*g>hifGeE|fL;`$FFytv8U>DvL~ZbL@p9L8 z={B~HPI+_WH9q?`r+OuqJh}ZC`4GdY~8EgNW@% zjl{M&by>2f|u;>1%7v$&uK+cVVUvG_T9zH)dnXGVi`$jlBcN zEBRbne=Kh4Ih*``lyN8W_t;#S?@%B1v#ywbkHUw%Mtr!mc2cwUUL_vcW1iDJz0xZ6 zb3>_%*$4E#{+N-QGJkvls&RyVZcIP7?!jqGskVXoTY zw}<1g<4Mnsk-QJlzJ|{BD7)Jp+;1n_^E{Irep#G=?v;(|mKL!~?J-gY&i8uN@B7{d z{Xb|_|1Rl{^aalM+*;#$#P<`?{eGjmTgG=+|K_QF-}k=g|6`;2Bh6q}+Cd}^&W^6r zY#e+$PQs4dOETkGwEne@9gEZszb^K}jzb%@Bib|ULYs)xNf(b^H#DplCu7I)ZDfaQ z8;jKrzg$kijx)3D7+YOdTcQ(FA%+n0~K0?rsd64ZUXA82C1v zfenk=zy{Y2m#GbYe=q zJqtU2;_Mh+R5PNYv_!gt;=+>Zsbw|tnhP_+%9?2ae(V5}-{tYwA5D4pt^YpX@cp=j z)nyfv%BqT3!**I=V zArXi8=8l2nxy0GdURu_xhs`rb?eVz>c_p7q>z8Bpo~~c6qxh>{EJ^#0sHiQeuB;ke zQhh_&B=am&{NLm9^M>V}Wt6ECgUhQ*i^@wXE6Qs6jxDP=^%UN|GHDuBaRz_84ekre zCRJC~R8FpSSBoZ>3@@rEmLG<4Nd4HA=hyclZ)5AsO&VXn|2P{(MG5h3PX8%o)tK(_ zw~ANMvOS0NRc)Yqqw4nk9)#|68|WT$oAowX^h?i(!Ud{*G|S-N_VeW4SgPp?%%eeZWr%GF}jDLdwZ@1CPG>%mN2Zkc$yInJUO-NVt{EmpTT@x|obEpul>UVTIVM_|LTZD_-i z7#q&Vh5@lQL?^y26^Gt)8ph!QY#7l7Hn?@@w%e@@I`uUtBeCHM--c<`)g=|-t#7kx zkp8s~_Aes8lPbA5${j><%5S^JyLr42RST{;KY|(dl+akrTCar&T?I6A|9`4Z{{i&K%`X4zRb7t1& z%$7&LeIJ+IY1}f;ci2xsa4`wa8k6a(8$8iPLh*4V@hK+1+;ep4{q~W)j_~W}&i;V$#GRvO-IQ^Sde@|Dy$V*6Hx)c3U#{I~<1V~<& zz9sLIs@;)iMclqg`Q6rFsbB6Gh23{1+3gMKyBj}e$9A>DFTc^)@l+ezv0|Q$f?tkf zu;b+>+9BonDZbRgBOESYYnP|nub6(1wSQk%n8-`9f1_u=d;V;O{B3xyi_I&sw;y>W zpG)iaGcCP_k#R1&Ejb^y$M|p=K75qmLv!k(#3Ng`n^#W17sELG_>Cp~_QrJYVp~YE zVMmM&`D!S!bw@3V0@%?k7H<=D`>=bGJYx0ikLdIpj*0Hn+f6EIJSrcn)Q?kd9Iy*J9D~n`IXYFD4BR9<#)_}hk znmMi@!BEe)k(E=*CKZ(zRF~agHowHL_wZ>hc_p7q>$eeq-*rf3d3njCTG`s|dtONe z`@NHb=8Vl^@2H*4_1FlIJ=m_m?Zt}p>vry5c3(ElkN!szA3qM|_mh~zkHeKDxH%yX z=QqVBEeDBdtS$WTf1KLl>f2VerIR(u{5zifUw5{I&%Q@XraA3C+a8I9YxkQTu!_5R z`mZ9vtI7IJt$(g5F`-}z;T{+a4Jv|Z!PKB6s1AyPTI9%}GMEyS@%VpHP#zTUeOYh= z-`4~~xKhohbAsaF8vZ*a=+A$0NL+g%Q?oBk&HhiSJ}*`OgH-(|shV~(ho|^|&TFKh z?4@p`d9gtHd#RbHYs}sAe)As`rf6SxH9pJlwn-WU>}?ko$+FFk5u1t8aPmms=+d2_>x8kfrS#`MWL%Dn zM@8uWcPs06`&%1S|7q3?^Y29Tcf2gSj@SV}`pNd>nGYn7OXvFki81}ZT$6J5uN9Y7 z%i_4%eZQ8a?fbi=(!bB@`?o!89r4HaN%%9^`NJAF>(+^xA8o{+737tCE^SlyCK_ua zO}TH=l)Yxm-=)8OEn|h`b>rfMM{I2TKDd|!7bnD~IctB3v#)Qx>hsH@gaqSTNnifL zhW<@P-?gozZ@KF8{hNZm8(T?V-lGluD@EU&R?@do^_^hVnt#jC_kgD_?it%&q-Vz=y`H>aLU419enRi7WH>qzin zBl^Uk-O<8 zuL6BnwXi-nH%zNOKc1E7o7IRuejnP|$-mkW@-l{L!`1Y~F{ChomH@1>q zw+FOU_4?&njo#dG@%1)(M`hRAjMH8EM8i5&gYM(nK=)?VeT*0HT6AC3in?82IOa=M zsb9CJp}W@89eu8J*W&Ev(`!|qU&c3}?@Nv9lip(2bUGggENI_Jmeya}CyT0y64qaB}WSdKTNv$#>6 zeowq>W$JX#jnQ3)?)%z6cka{HZ@)jj1>N6j1KnxW?boea(fv`Qx}&}Fu8e;!<~w3^ z--hmexWOjt#ejKCgL>^1`R?eRzQo4d?~~K$?$?UC-I{x|>OR?;VE&zn?#n#gGH={bu6lHBjn%d5 z{h`yhNcH7;`sSc-A8t;&x|%7o-PhOgS*xh0r|)+3ozTMi++4I?_4#%34)l$T)#o)r z?Aw)g==APTy?*_ii{4vWS#Rx98(6=t-ih89T3PQ_)tl#)>s{#mFjnvG_q8t0#b2=s z{rYq_dUM7%Qh&W7-ktJ&PxT(@`8yB2N41h(*Iws7XBGN;UH71OsMBlw^ zYqvi~djPwaG-kIQewx)UOC0z=tdsLpryr{aN$_T4Ix(?1buwGuju?Fl(6_yX^|_c< zeXU_kA41;|S7rJ`nR|wHVK-vxbZ(B(`7k;QT0y7l_s73r{q)Q65povmGzEXZvFMwQjendwN}#W`qZ_m*Kebbq4(p)^hSsFU1~c{cfr>i*5$|1 zE$`HHbJOg)>=pBF>0Yh6{dLqLbf4CWy50Ta^f#>E2UubL{UW-rbh?LBPOYjgsbL9a z#`ZPXT0kC2@6!1Fc=ofFEj{kIc-s5;Oi-T(S*kMZ9fIU zmq>713+q`Kqh~RC?r$MIZXEBuqM<)eqUY&sJzgc>mH0V*3uE*>g}#?sNniVy8v6G% z`hL(#`liR|TY|n{w6H$cZa2l~dj@?UJADNulU&Q)m2z`>hJUkR9KVd7f3>ilXdcrC1X^FP-|Ii11EhQ2+A&Y`WS zvo=QO^XMGgiaNK%=v;=*vR2UP`mb@X*x1UN)*W9(=gpzcvYMia+zZcQ>W~2Hd#kxzrI^7Fnbgw}7yRE3(^@a1k zWBulKe0aQs?%z7yuAyee74vYO>{Tqn?&0K@ye_?aHm^A5**x>yGkFTg(}g^HPOxK^ zsb?{XC-<@wXmK(uQl}N74%%)!g?0O==m0U zu625bR!nM%^4Sri=iBJHp@sDnuMW)N*Mn8)nbpF2*2U=g4tnlwAw6y^82DY|POy&^ z=HFM*^O)09V8?hZCK=*)sU10e%VPAshQ4Q7NnelGtz*7_tI@aI>9b><@7`|tH!nut zchUFl7S`v+o5Jr||IV_){QElk-iYdJP>TAq9J9YMADcVEBOETD>-$S$`hMtlr4P5y zUf;lvVP~bySm1o9T4Rl8%m|O~iIO7i!?ko6wxp{Ff8yl(Fb4a3!DBcypYvgIj1O`x zg*N}1d*`+p58=y$PsX->9$#)&p6s!$IlmLuu`Q=NoGG43|7On2vF&EAO3h?k75ClW zT-)@05^(Hqh52_435qlEnKregx~R59el0wr_}t3c(lAK!cW=odKGovSLb!y-a3`!YSt9TC z{SgUHo~UyH`RySuzbmP(l|LzI#*SP&W80dHvAMD>e|qTF+Xk?hYi?pcN^NUF~)|UVZ&o>V1rwmmcL`;@b8qB^6$IY z@Re8_Y$t2>!LWVnPl7=5xwMA_C+>eOQ|->_+(2gKRrFaRg)?()&tObtZBe;gG#~tH zxxwhNn@m2DHea5ZlCqf=PEBhizu~m&8UI?1=9Bj*0DR1G`J~ima=hXhG<5TH3Q|TS4nWv^^u535!>eQ^OkC@#q zXZG>!W36-- zE+ntBx6iwxHQI*WBf%e=Xm4}w8%P{{-AiM1|C$7!Io%_sCdO)abocssL%-ig_uh;q zrtfG)-HT&%e}L|T+CX=YjSctx{%|E2**nazC5TL3y>0zheD1ABOLE0aPSDc@#T5tSQc{J9^v>$ zf-m1wjx|V$$M-{yZ$vl_r@*9ady_^EKc>G@j`xtqaP8M2$1@R*VagF#KmJ!a{)v=$ zd=_$Km2CnCo7yHG2Ox!`3)0rH>WCe4mE%a#$l?2PqH^>_=5g($kmKP9$8*YYln`+E z9K)4k1X6rGKjgSG!tr*3FO!s`7%9G#gdEYb{ZoQ3b;@xIG7pYhLyj2{J30@rWgF+q zqss9ZQha$l-$Y8xUk*9uM>xhRhv<>R=h&beKSN49-VHhG zBOKEcIR2;{e^QP=ha5LXI37*lXrE*2*xpF7qXW{`vAZK2-%8-fQ;wd>!6uM$+#2Ed zRRYI3$}vbe@^GDtb% z>KMOwG41wVq?A3st5J?9EiLeIS6?r@?50YGXzkt2~ykcG$< z$Wh2|BQHh1j+FFrJLodbE46l-|oe#mQ)ydKM>KLmLl=e?2T$m5We$WxIu$g_~bdk(Ue^FhdI$ic`P zk@Ww;45Ykc@FwIKLR--n9-DzYc?H6(2!ScB}1{65n5+r62Co&tt~!>JMU={ynAiStg}h3*tw4{iqI z&9%-*x!xf-5)1=JfLXxKjBMU7k$ws|4IFIpbz-&GIT!bB?xp*JrW=IxxsD=@;Bat;Nn`Dj*6e(k%J*Hd)GqG3k=E)dAd)8j8YD%YvPO4HEYL|2uIfhjw0ols2r0*j_5q^s05Bm z<)~7Q>qCx`h#jXSaNMRGY2}z1a@-u@7_1ypuGwYl*Hekt{E(v}@*?Cn zkQXCYAn6NCI++u_#Cb9DWhCu8ScSYnud|mBNS%Kaxf=O6@^$1BNYV2Y@_U@qrp(%$ zHf1Dv%yrs_IbVx>gLFUF^AGj#TMvce_f z?f#6OM3tjUa46s1#^`vsIqx7*o0Lo7(| zhwK;nQykV6#)05Y<&d(^=AarG4w9q~;Cg<@k*ROOu_(cgLglywDRxMkws9RBv13_+ z9nxmS7wVC*gSoYG6h$~*OW>f+8IBv3V|vIDUH`t5z%f@j?o^JuLXK-AcKlC5JRVaH z>bi-?qL3rnKmRR(<9X$fwkk1|Hfm!U?VtC|xAh~gY+qH5*N{@St3!@y5ns9|aI9C3 zpD4#WAxCM1%9{&90~aP>xTL;_Ls09M^|-?4WUsQVyA$ z3&&`%O&Se{?3YO$WBo%cZNJa~N#9^N4@OEJ*Dta@GW}v6@>IU>iIkq=DCC)%PTEE< z&IcpuTg=)~_Si1d>sKIUuk9-2DM(o}3V#`rbyoUXWPfB0@^s`Kdi`$X8JsUbvJOi> zgghI$P_I*`0@h{eFCz1i(w~ZaQLjtyBIneBfc09MIuM+Tlzvq7(>De~IR5}S6uAvK z4EYzNxHS{E_^cAPebxv_cXQ#mm{$;V7-?{m$^O*c@^ik z>-k;CYdF6j$$BvTFmf{TNxl9Iath}kAxn`TBg>KOWf{ItkW)GT6v_HA{V!xSQr3Po zNcOLS8<3rmHzE&1&Or7-ia-63H*tP4@@6FaOXm9_NZC&;K;DKNuHTPDra8Y5i7)A^ zkh75!k#``=kgQkJ*COvmvQK3AZbaV0c^Y{iau!nd8t+CvhMb4|A~JdW*(+B{&Z zV-CGGM<=s3qxa{qgb2q0 z2^^)$L5Uj<`V!?B9pN}Cf#YW7s8fzxLXPNo*FS;d9_6@KIqnNNqA?ws!11JVJf$2@ zha6KQzFd~Tu|hdyJ}PDV&5$D+(w8-Iery#jEnek zX9C9`mE%v!@#l~uI_^G}z(LhBbu5LHc;tlr&6N>5o=@QDsvHL@N4Jn8y0%)Cz`=XIDW1i z8T;_(IL7>Ja3oE>sZjBvb~U`L^HT!NH% zj0!oT_ndy5U`MfXlpw{9$stEHroTzxxJfx~R*t%mqb}mhC(6+UJ$b9GRH1&(8}gY}@BqF2gaBwA^1X$JdnO1(TP(6{Ps|4dlT{e$$=qh2(d^W)DW@ ztg`lag>$AP!7Aj1NcsK}Q_{~oGF63IItR3D$E<*BK40FFp^2u6Y z9p~Ri{s<{E!XG35fRyWuIl+3)|B2*T;q)Fj&9ky*?l0F5;GE~$%-#ym@}&>vT)saP z$vup84u`$;@Al^(+RuaWe(Cf#L7xsNzO&*@Wx-*C=+KiGt%Pc!M5KL;OjelJq= zEKvC+z5Zq7Z~6XNf?I8BjRs-&-q-m?c zKaqPOcOW|=<@)i+)E+_lG(A5PnZx{DSDqk9>n=`$nMDJkz29rWxf6?@({kKY)yK~BIv=n z?RN(=A1(kR!E;~~r6_BKF?=4apGWceSuh=30*(Ub>a}ismN~Voa3!Cl?E{W9=Q7tm zK<}m4do2Tl&dkj_>l&d;Ahp--cXbXfGM^>gAkrMq{+b-Zv43!_k#cT%PK2XgPLXoI zW)N`efQjb&9^9`wI4IW7llXiDI8Wt0$PwnV~RkXITnN*!^xM+KQd?N zp&YqLu}_Z6m4p3+bSKWoBM(8+_S3f9A0wXALq5rur+jgKO;x@Mr1(`C@Xy+!uL!$dS1pB7PMl`1M8QVE@ASwHPUWJsEO|UzvR~DZL5GcLbk%gFS)h zk>l&i_oB&f_o_Scy{rWeL&_etjn@Ep&jj^h%!K>41nxJKd#!TI+CaE}h!pO1=6iYO z&v9q=9fkV|$%5g4I+D8FW>XGbiW!gvd-e=bljkkNoC}Y!D zr1&L!T#iTNU-?e_>a84ce#!on_*ID%zp6rxdn0}gP!6d>*?#%+eDO>6n56#93%R6y zWY%I*7cN!4xb`7)e6fi!6n}zXF;eQnQ%KSOwE5nzXLpCT3U_S+_lx8eZpK~1&A4m0 zS0aV`74yB%o!S2t?gy1Su6_KNyu$qx!x04UAjR$tNU6g=GvE8%nX(q{uPL{yJAT{y z19^p8=KT^AnfD9#pOI3BwwdpJ?o7O;4!ot@UHRM(`0e9FZF_x@Qjap@#}i>(h2wqY zkb0EOF<3bojvo(%9MV4iZ=?*_?+$67d1AGk00V!razOqaK7?M`w%|AE;N1oI1Ao0Kz(SdaF-=; zH+}qY+|lu4u5wHJ$hP}88i$>aAC5ay)?)Y53EWK|KOA=^-cko%RqnX<(fIiBOc+<; zct<(n>XD2W(tb}sN>@cLX{qsUDsYjVUMQr+a zf?qOTh)tIxrQORt5j%b?3~dsQ11_*_EY2?(FNEWIr1(`Ga%7$Z62FdA4(Vg1Uij@^ z_JxE)#trdH?ny}fVNDg)SdJ!$gWaYOpbC7g?X?%yb{s|(TbA2MzT_fHLn9XEvgUCw3vko_ZDK8`z6 z*3v!}Dz~dUexD)ZhH(E$xn@R#akX+>6LLhKVSX=xBdr`Wm19=Ok%^Pk=WPibPbtUK%CRKmh{hv# zWTs7I$Ky@qcnc|Q;)fx}BawJ?P2l*ma%@wMzl0ojML2pTa2!OLN||>@iXH5MXt_k6 zYwMrDA$!=uF-SS`LypN2I|`H|u6`6L2YV={eoP8Eo{MmdOW>HT9QDdEC*+7e(_Nmx z!5)n9WvOy}CFF=cUndV$%NjS%m$#JThsv=oI5XGqdZ5v^9z8CrBxm?IA~W zzO^KQ<6!n$gyRsTa2$%XeM59^vm$|mJtD)wePzSJeP!i{KIgYaIrc|SwlCKz$92g4 zxLzJ|WbTPc|Nk@PI9@sY{{JE6cm&yj>yILPBiUV)uSeQ4 (V|0RFvi~6*cOa$S%ndp2i}*Du!LKhV$6}=T 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 diff --git a/NTFSSecurity/NTFSSecurity.csproj.user b/NTFSSecurity/NTFSSecurity.csproj.user new file mode 100644 index 0000000..5283ef1 --- /dev/null +++ b/NTFSSecurity/NTFSSecurity.csproj.user @@ -0,0 +1,6 @@ + + + + ShowAllFiles + + \ No newline at end of file diff --git a/NTFSSecurity/obj/Debug/TempPE/Properties.Resources.Designer.cs.dll b/NTFSSecurity/obj/Debug/TempPE/Properties.Resources.Designer.cs.dll new file mode 100644 index 0000000000000000000000000000000000000000..1c7e5d661ab101e7fc386e42bbe355d873d9e613 GIT binary patch literal 3584 zcmeHJPiz!b82{evc6Zsr$}U2vG&-f!v{WYLkHIQR+uc%XC^X$g)L>wC_puC_ompmP zfpWk`W7LEgi9m>n7xZHEV3Z(Hxfl{PiZLd}L^*KsWQ-Rt9>m}Gc80A$haB z^LyWW@Av-fOg;NL#fT`5dhHs~1+-j7l)Sx|LpbxmCmA}o;BwCevF&nCX}{&`4bQE4 zW?iqCj^hS;S?XTX(Je?rDWwF=C2i&DmtcTc+z$&;T%Tb=C$20A-Koj{ZHj2*3X6KrcnoV z_Yf75L_&G*Ts)}tV@24w)kI5%G#W+<gm(ZCtkz2Dq{zr!idb zF{01VUSYi$c$QQ18F8kAXbx@f&LS;Ow9Z}c#LmeAeEqPyvDDr%+bzT9g6?A1(z61T z5dA6E)3Vk+@bN`VRdiD`!gSU7;&YEQ>ilCkrSp9z+Ar7-GUyMowFE5{EWe~@w0r0+ zq)XFD8i40LcoHO7NR#jk zK@N)%$V=K3`aVWkVc^8QNe0&WHslKWobuF5UqcSkLXoHSkdq484MsN61ZKl5bZIX` z?xy3Am&FOlaqSdh8crwI4xr+YeAkkY30gq$Il%r=P9PQUcvMR2dAQMcUeP`u_Z;P0 zTS2sG%B?nS`2^MditE`{nP!?!VAW-5wjsBgPSut)Ap^Fycy2xPut_x;?8!Inpy^5S z=jopG-KJNOQEa?w1+F*dxrcqTY|CO`29ok_y8Iy-&o-73iG+Z}Egw;gDWZ3dR>%t+fjqBOr94;f$>LS@Ugg4uTTkZCs+ zC#@??#aTa)b)(>!hjF7LlRLYPbOP`zZJPGnhV%kU`o>I1k8c#DZ`H7Tqv9J?+vfVO zfZ-Sv5j|x(t<7+qz_gHXvf?_?L?-ZXn6`CPEi!V>$bGh~FaZ?q(xkJ`r7ndbL>9isboCAyrl%w#I$i+Td5otGL_(uM+eC?0Fof+JA z>h#RTZ@NBum*Tn*shCcp14=gAp=%Loj<2vO=6CBTt#*-p9 z5KD>->`W#%(2>--b8BF9!$^I6boWzT8?L^Z`e5^(=d(YgAB`n)eW(L?@pFAF2Jn_} z27H9Exh9_C0K`Bn1s9YxDG`2z+|Ms_Nn5tdGaI;P<3}p8!Kb9OpKq@KE~y@l5xl42 zxsMKtZ#W^e zqVJGaWKZ7p3bs9kL*IJ8q*RxPqu2V7Lw(WRoaL_Pjv3HfpOfbvx#OO9JNyqA_#2wb B@TmX* literal 0 HcmV?d00001 diff --git a/Security2/bin/Debug/AlphaFS.pdb b/Security2/bin/Debug/AlphaFS.pdb deleted file mode 100644 index 6758b597a2f28bc5108b8821e8ebaf63adb92374..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 947712 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